Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Render workspace: one editor per Browser selection; delete the Render studio panel (#6281) (#8000)

Nathan Dane3ddd73728bbe
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index b83301bfef..2bcfc14c9b 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -1200,14 +1200,12 @@ impl SolveApp {
// Render focus already applies its semantic selection after clearing object picks.
// A tab switch brings in the other design's own Render selection.
if done.is_ok() && !matches!(id, "view.render_select" | "view.next_tab" | "view.previous_tab") && selection_changed {
- if self.session.selection.is_empty() && render_workspace::active(self) {
- render_workspace::selection_editor(self, &render_workspace::RenderSelection::Nothing);
- }
- self.render_workspace.view.selection = if self.session.selection.is_empty() {
- render_workspace::RenderSelection::Nothing
+ let selection = render_workspace::object_selection(self);
+ if render_workspace::active(self) {
+ render_workspace::selection_editor(self, &selection);
} else {
- render_workspace::RenderSelection::Object(self.session.selection.clone())
- };
+ self.render_workspace.view.selection = selection;
+ }
}
if let Ok(v) = &done {
if matches!(id, "render.lights.solo" | "render.lights.mute") {
@@ -1281,23 +1279,16 @@ impl SolveApp {
let selected = match v.get("kind").and_then(Value::as_str) {
Some("environment") => RenderSelection::Environment,
Some("wear") => RenderSelection::Wear,
- Some("lighting") => {
- render_workspace::select_lighting(self);
- RenderSelection::Lighting
- }
+ Some("lighting") => RenderSelection::Lighting,
Some("output") => RenderSelection::Output,
Some("sampling") => RenderSelection::Sampling,
Some("effects") => RenderSelection::Effects,
Some("check") => RenderSelection::Check,
- Some("light") => {
- render_workspace::select_lighting(self);
- RenderSelection::Light(v.get("id").and_then(Value::as_str).unwrap_or_default().into())
- }
+ 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()),
_ => RenderSelection::Nothing,
};
render_workspace::selection_editor(self, &selected);
- self.render_workspace.view.selection = selected;
}
if id == "view.layout" {
let layout =
diff --git a/crates/ui-egui/src/render_ui/appearance.rs b/crates/ui-egui/src/render_ui/appearance.rs
index 36265c03b2..ef0df59379 100644
--- a/crates/ui-egui/src/render_ui/appearance.rs
+++ b/crates/ui-egui/src/render_ui/appearance.rs
@@ -221,7 +221,7 @@ fn ended(response: &egui::Response, ui: &egui::Ui) -> bool {
|| response.changed() && !response.has_focus() && !ui.input(|i| i.pointer.any_down()) && !ui.ctx().egui_wants_keyboard_input()
}
-pub(super) fn scope_label(app: &SolveApp) -> &str {
+pub(in crate::render_workspace) fn scope_label(app: &SolveApp) -> &str {
app.tr(match app.session.selection.last() {
Some(Sel::Occurrence { .. }) => "render.pick_component",
Some(Sel::Face { .. }) => "render.pick_face",
@@ -254,7 +254,7 @@ pub(super) fn reset(app: &mut SolveApp) {
}
}
-pub(super) fn remove(app: &mut SolveApp) {
+pub(in crate::render_workspace) fn remove(app: &mut SolveApp) {
let view = &app.render_workspace.view.inspector.selection_appearance;
let selected = targets(app, view.inspected.unwrap_or(mode_step(view.mode)));
if let Some(look) = view.draft.clone() {
@@ -265,7 +265,7 @@ pub(super) fn remove(app: &mut SolveApp) {
}
}
-pub(super) fn footer(app: &mut SolveApp, ui: &mut egui::Ui) {
+pub(in crate::render_workspace) fn footer(app: &mut SolveApp, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
let enabled = !app.session.selection.is_empty();
if ui_kit::icon_label_action(ui, app.tr("render.inspector_save_library"), Some("plus"), enabled, false)
@@ -283,7 +283,7 @@ pub(super) fn footer(app: &mut SolveApp, ui: &mut egui::Ui) {
}
/// Returns false only when the explicit-target fallback should be shown.
-pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
+pub(in crate::render_workspace) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
if app.session.selection.is_empty() {
app.render_workspace.view.inspector.selection_appearance = View::default();
return false;
diff --git a/crates/ui-egui/src/render_ui/assign.rs b/crates/ui-egui/src/render_ui/assign.rs
index ae80e0694b..79472aeb09 100644
--- a/crates/ui-egui/src/render_ui/assign.rs
+++ b/crates/ui-egui/src/render_ui/assign.rs
@@ -563,61 +563,6 @@ pub(crate) fn selection_bar(app: &mut SolveApp, ui: &mut egui::Ui, free: egui::R
}
/// Existing appearance commands exposed alongside the shared inheritance widget.
-pub(crate) fn selection_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- let Some(sel) = app.session.selection.last().cloned() else { return };
- let Ok(target) = chain_target(app, &sel) else { return };
- if let Ok(chain) = app.session.execute("appearance.chain", &json!({"target":target})) {
- let steps = chain["steps"].as_array().map(Vec::as_slice).unwrap_or_default();
- let looks =
- std::array::from_fn(|index| steps.get(index).and_then(|s| s.get("look")).filter(|l| !l.is_null()).map(super::library::tile_sphere));
- let active = match chain["active"].as_str() {
- Some("face") => ui_kit::LookStep::Face,
- Some("body") => ui_kit::LookStep::Body,
- Some("component") => ui_kit::LookStep::Component,
- _ => ui_kit::LookStep::Material,
- };
- if ui_kit::look_chain(
- ui,
- "render:look_chain",
- [app.tr("render.pick_face"), app.tr("render.pick_body"), app.tr("render.pick_component"), app.tr("render.look_material")],
- looks,
- active,
- )
- .is_some()
- {
- app.start("appearance.assign");
- }
- }
- ui_kit::dropdown_menu(ui, "render_selection_actions", app.tr("cmd.appearance_assign"), |ui| {
- for (id, label) in
- [("appearance.assign", "cmd.appearance_assign"), ("appearance.replace", "render.replace_all"), ("appearance.copy", "cmd.appearance_copy")]
- {
- if let Some(command) = solidcraft_engine::find_command(id) {
- let info = command.info(&app.session);
- if ui_kit::command_menu_button(
- ui,
- id,
- app.tr(label),
- command.icon,
- &crate::keymap::display_for(app, id).unwrap_or_default(),
- info.enabled,
- )
- .clicked()
- {
- app.start(id);
- ui.close();
- }
- }
- }
- if ui_kit::command_menu_button(ui, "render_remove_override", app.tr("render.remove_override"), "delete", "", true).clicked() {
- if let Ok(targets) = targets(app, &app.session.selection) {
- let _ = app.run("appearance.assign", targets);
- }
- ui.close();
- }
- });
-}
-
pub(crate) fn replacement_dialog(app: &mut SolveApp, ctx: &egui::Context) {
let Some(pending) = app.render_workspace.view.assign.replacement.clone() else { return };
if pending.revision != app.session.revision || !pending.document.ptr_eq(&std::sync::Arc::downgrade(&app.session.doc)) {
diff --git a/crates/ui-egui/src/render_ui/inspector.rs b/crates/ui-egui/src/render_ui/inspector.rs
new file mode 100644
index 0000000000..52e1932703
--- /dev/null
+++ b/crates/ui-egui/src/render_ui/inspector.rs
@@ -0,0 +1,190 @@
+//! One floating editor for the selected Render item.
+use super::{RenderSelection, environment, inspector, library, light, setups, shot, wear};
+use crate::{SolveApp, ui_kit};
+use inspector::selection_appearance;
+use serde_json::json;
+
+pub(crate) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
+ // Reviews belong to the workspace, including when their originating editor closes.
+ inspector::confirmation(app, ui.ctx());
+ library::review::dialog(app, ui.ctx());
+ library::review::confirmation(app, ui.ctx());
+ if app.render_workspace.view.inspector.hidden || app.render_workspace.view.selection != RenderSelection::Environment {
+ environment::stage_confirmation(app, ui.ctx());
+ }
+ if app.render_workspace.view.inspector.hidden {
+ crate::shell::register_panel(app, "render:inspector", None, None);
+ return;
+ }
+ setups::refresh_dirty(app);
+ setups::sync_revision(app);
+ let selection = app.render_workspace.view.selection.clone();
+ let kind = kind(&selection);
+ let appearance = matches!(selection, RenderSelection::Object(_));
+ let (title, icon) = title(app, &selection);
+ let scope = selection_appearance::scope_label(app).to_owned();
+ 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 action = std::cell::Cell::new(None);
+ let content = ui_kit::Panel::workspace_with_header(
+ ui,
+ ui_kit::WorkspaceOptions {
+ id: "render:inspector",
+ title: &title,
+ icon,
+ bounds,
+ fill_height: true,
+ compact: crate::render_ui::compact(app, bounds.width()),
+ editor: appearance,
+ enabled: true,
+ header_actions: None,
+ },
+ &mut side,
+ &mut width,
+ false,
+ |ui, options| {
+ if appearance {
+ action.set(ui_kit::inspector_header(ui, options.icon, options.title, &scope));
+ } else {
+ ui_kit::panel::header(ui, options.icon, options.title, || action.set(Some(ui_kit::InspectorAction::Close)));
+ }
+ },
+ |ui| {
+ if appearance {
+ ui_kit::Panel::editor_footer(ui, "render_appearance_footer", |ui| selection_appearance::footer(app, ui));
+ } else if selection == RenderSelection::Output {
+ ui_kit::Panel::pinned_footer(ui, "render_output_footer", 1, |ui| {
+ output_actions(app, ui);
+ crate::scenario::publish_rect("render:output-footer", ui.min_rect());
+ });
+ }
+ egui::ScrollArea::vertical()
+ .max_width(ui.available_width())
+ .id_salt(("render_inspector", kind, app.docs.active))
+ .auto_shrink([false, false])
+ .show(ui, |ui| {
+ let before = setups::draft(app).ok();
+ let rollback = app.render_workspace.view.clone();
+ let response = ui.scope(|ui| match &selection {
+ RenderSelection::Nothing => inspector::scene_controls(app, ui),
+ RenderSelection::Object(_) => {
+ selection_appearance::controls(app, ui);
+ }
+ RenderSelection::Wear => wear::controls(app, ui),
+ RenderSelection::Environment => environment::editor(app, ui),
+ RenderSelection::Lighting => light::lighting(app, ui),
+ RenderSelection::Light(id) => light::editor(app, ui, id),
+ RenderSelection::Shot(name) => shot::editor(app, ui, name),
+ RenderSelection::Output => inspector::output_editor(app, ui),
+ RenderSelection::Sampling => inspector::sampling_editor(app, ui),
+ RenderSelection::Effects => super::effects::output_controls(app, ui),
+ RenderSelection::Check => inspector::check_editor(app, ui),
+ });
+ if matches!(selection, RenderSelection::Output | RenderSelection::Sampling | RenderSelection::Effects | RenderSelection::Wear)
+ && let Some(before) = before
+ && let Err(error) = setups::persist_editor(app, &before)
+ {
+ // Refuse the numerical edit without undoing transient editor navigation.
+ let inspector = std::mem::take(&mut app.render_workspace.view.inspector);
+ app.render_workspace.view = rollback;
+ app.render_workspace.view.inspector = inspector;
+ app.set_status(error, true);
+ }
+ crate::scenario::publish_rect(&format!("render:editor:{kind}"), response.response.rect);
+ });
+ },
+ );
+ match action.get() {
+ Some(ui_kit::InspectorAction::Close) => {
+ let _ = app.run("view.render_inspector", json!({"visible":false}));
+ }
+ Some(ui_kit::InspectorAction::Remove) => selection_appearance::remove(app),
+ None => {}
+ }
+ app.preferences.render_inspector_width = width;
+ let requested = content
+ .as_ref()
+ .and_then(|c| c.inner.1)
+ .map(str::to_string)
+ .or_else(|| (app.preferences.render_inspector_side != side).then(|| side.clone()));
+ if let Some(side) = requested {
+ let _ = app.run("view.render_dock", json!({"panel":"inspector","side":side}));
+ }
+ let rect = content.map(|content| content.response.rect);
+ crate::shell::register_panel(app, "render:inspector", rect, Some(if side == "left" { ui_kit::Edge::Left } else { ui_kit::Edge::Right }));
+ if let Some(rect) = rect {
+ crate::scenario::publish_rect("render:inspector", rect);
+ }
+}
+
+pub(super) fn output_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
+ ui.horizontal_wrapped(|ui| {
+ for (id, label, target) in [
+ ("render.start", app.tr("cmd.render_start").to_owned(), "render:output:render"),
+ (
+ "render.batch",
+ crate::i18n::format("render.batch_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]),
+ "render:output:all-shots",
+ ),
+ ] {
+ let ready = super::ribbon::action_ready(app, id);
+ let response = ui_kit::icon_label_action(ui, &label, Some("play"), ready.is_ok(), id == "render.start");
+ let response = if let Err(reason) = ready { response.on_disabled_hover_text(reason) } else { response };
+ crate::scenario::publish_target(target, response.rect);
+ if response.clicked() {
+ app.start(id);
+ }
+ }
+ });
+}
+
+fn kind(selection: &RenderSelection) -> &'static str {
+ match selection {
+ RenderSelection::Nothing => "scene",
+ RenderSelection::Object(_) => "appearance",
+ RenderSelection::Wear => "wear",
+ RenderSelection::Environment => "environment",
+ RenderSelection::Lighting => "lighting",
+ RenderSelection::Light(_) => "light",
+ RenderSelection::Shot(_) => "shot",
+ RenderSelection::Output => "output",
+ RenderSelection::Sampling => "sampling",
+ RenderSelection::Effects => "effects",
+ RenderSelection::Check => "check",
+ }
+}
+
+fn title(app: &SolveApp, selection: &RenderSelection) -> (String, &'static str) {
+ let (key, icon) = match selection {
+ RenderSelection::Nothing => ("render.page_scene", "render_scene"),
+ RenderSelection::Object(items) => {
+ let name = items
+ .last()
+ .and_then(|item| match item {
+ solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name.clone()),
+ solidcraft_engine::Sel::Occurrence { path } => app.session.occurrence_placement(path).ok().map(|p| p.name),
+ _ => None,
+ })
+ .unwrap_or_else(|| app.tr("render.page_appearance").to_owned());
+ return (name, "body");
+ }
+ RenderSelection::Shot(name) => return (name.clone(), "camera"),
+ RenderSelection::Light(id) => {
+ let name = light::rows(app)
+ .ok()
+ .and_then(|rows| rows.into_iter().find(|row| &row.id == id))
+ .map(|row| light::name(app, &row))
+ .unwrap_or_else(|| app.tr("render.tree_lights").to_owned());
+ return (name, "render_scene");
+ }
+ RenderSelection::Wear => ("render.wear_title", "appearance"),
+ RenderSelection::Environment => ("render.page_environment", "environment_map"),
+ RenderSelection::Lighting => ("render.page_lighting", "render_scene"),
+ RenderSelection::Output => ("render.page_output", "export"),
+ RenderSelection::Sampling => ("render.children.sampling", "settings"),
+ RenderSelection::Effects => ("render.page_effects", "camera"),
+ RenderSelection::Check => ("render.children.check", "inspect"),
+ };
+ (app.tr(key).to_owned(), icon)
+}
diff --git a/crates/ui-egui/src/render_ui/scene.rs b/crates/ui-egui/src/render_ui/scene.rs
index 0b293f426c..ee1eb5005d 100644
--- a/crates/ui-egui/src/render_ui/scene.rs
+++ b/crates/ui-egui/src/render_ui/scene.rs
@@ -105,13 +105,13 @@ fn section(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) -> bool {
crate::scenario::publish_target(&id, rect);
}
if row.actions.iter().any(|r| r.clicked()) {
- // The existing Shots manager owns naming and saving. This navigation never saves.
+ // Shot naming and saving use the existing Save shot prompt.
if key == "lights" {
if let Err(error) = super::light::edit(app, "render.lights.add", None, Some(json!({"kind":"area"}))) {
app.set_status(error, true);
}
} else {
- app.start("render.settings.get");
+ app.start("render.settings.set");
}
}
if row.clicked && key == "lights" {
@@ -200,7 +200,6 @@ pub(crate) fn sections(app: &mut SolveApp, ui: &mut egui::Ui) {
}
if row.clicked {
select(app, "environment", None);
- app.render_workspace.view.inspector.page = inspector::Page::Environment;
}
if section(app, ui, "lights") {
for (index, light) in super::light::rows(app).unwrap_or_default().iter().enumerate() {
@@ -243,7 +242,6 @@ pub(crate) fn sections(app: &mut SolveApp, ui: &mut egui::Ui) {
}
if row.clicked {
select(app, "light", Some(id));
- app.render_workspace.view.inspector.page = inspector::Page::Lighting;
}
}
}
diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs
index 7a786a094c..bcb40c1b7f 100644
--- a/crates/ui-egui/src/render_workspace.rs
+++ b/crates/ui-egui/src/render_workspace.rs
@@ -38,8 +38,10 @@ mod hdr;
mod effects;
#[path = "render_workspace_environment.rs"]
mod environment;
-#[path = "render_workspace_inspector.rs"]
+#[path = "render_workspace_output.rs"]
mod inspector;
+#[path = "render_ui/inspector.rs"]
+mod inspector_panel;
#[path = "render_workspace_library.rs"]
mod library;
@@ -304,14 +306,6 @@ impl Stage {
Self::Output => "render.stage_output",
}
}
- fn page(self) -> inspector::Page {
- match self {
- Self::Look => inspector::Page::Appearance,
- Self::Light => inspector::Page::Lighting,
- Self::Frame => inspector::Page::Camera,
- Self::Output => inspector::Page::Output,
- }
- }
}
/// Browser focus is transient per-document view state, never part of a saved design.
@@ -332,18 +326,18 @@ pub enum RenderSelection {
Check,
}
-/// Selection-driven homes introduced by E1/E7; remaining editors retain their adapters.
+/// Focus a Render editor without changing the shared modelling selection.
pub(crate) fn selection_editor(app: &mut SolveApp, selection: &RenderSelection) {
- app.render_workspace.view.inspector.page = match selection {
- RenderSelection::Nothing => inspector::Page::Scene,
- RenderSelection::Shot(_) => inspector::Page::Camera,
- RenderSelection::Output => inspector::Page::Output,
- _ => return,
- };
+ app.render_workspace.view.selection = selection.clone();
+ app.render_workspace.view.inspector.hidden = false;
}
-pub(crate) fn select_lighting(app: &mut SolveApp) {
- app.render_workspace.view.inspector.page = inspector::Page::Lighting;
+pub(crate) fn object_selection(app: &SolveApp) -> RenderSelection {
+ if app.session.selection.is_empty() { RenderSelection::Nothing } else { RenderSelection::Object(app.session.selection.clone()) }
+}
+pub(crate) fn current_shot_selection(app: &SolveApp) -> RenderSelection {
+ let name = &app.render_workspace.view.name;
+ if app.session.doc.render.setups.contains_key(name) { RenderSelection::Shot(name.clone()) } else { RenderSelection::Nothing }
}
/// Small per-document editor state; GPU uploads and host capabilities stay outside tabs.
@@ -363,6 +357,7 @@ pub struct ViewState {
draft: RenderSetup,
dirty: bool,
clean_setup: Option<RenderSetup>,
+ clean_name: String,
job: Option<solidcraft_engine::render::job::JobId>,
completed: Option<solidcraft_engine::render::job::JobId>,
retained: Vec<solidcraft_engine::render_jobs::RetainedResult>,
@@ -431,6 +426,7 @@ impl Default for ViewState {
draft: RenderSetup::default(),
dirty: false,
clean_setup: None,
+ clean_name: "Studio".into(),
job: None,
completed: None,
retained: Vec::new(),
@@ -699,9 +695,7 @@ pub fn enter(app: &mut SolveApp, render: bool) -> Result<(), String> {
}
}
setups::refresh_dirty(app);
- if app.render_workspace.revision != app.session.revision && !app.render_workspace.view.dirty {
- setups::load(app);
- }
+ setups::sync_revision(app);
// Fit once the setup in effect is known: the fit frames that image's aspect.
if entering {
let scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|e| e.to_string())?;
@@ -742,7 +736,6 @@ pub(crate) fn select_stage(app: &mut SolveApp, key: &str) {
};
app.render_workspace.view.stage = stage;
app.render_workspace.view.inspector.hidden = false;
- app.render_workspace.view.inspector.page = stage.page();
let sections: &[&str] = match stage {
Stage::Look => &["objects"],
Stage::Light => &["lights", "environment"],
@@ -815,7 +808,7 @@ pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
if crate::render_ui::focused(app) {
return;
}
- inspector::panel(app, ui);
+ inspector_panel::panel(app, ui);
}
/// Interactive stage-panel review. Direct engine JSON calls remain dialog-free.
@@ -1149,6 +1142,7 @@ fn image_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
completed_image(app, ui);
}
+#[cfg(test)]
fn job_controls(app: &mut SolveApp, ui: &mut egui::Ui, compact: bool) {
let params = image_params(app);
if !compact {
@@ -2392,16 +2386,5 @@ pub(crate) fn comparison_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
compare::controls(app, ui);
}
pub(crate) fn start_interactive(app: &mut SolveApp, id: &str) -> bool {
- let handled = assign::start(app, id) || 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"}));
- // Clearing semantic focus routes to Scene; retain the explicit Advanced destination.
- app.render_workspace.view.inspector.page = inspector::Page::Appearance;
- }
- handled
+ assign::start(app, id) || ribbon::start(app, id)
}
diff --git a/crates/ui-egui/src/render_workspace_cpu.rs b/crates/ui-egui/src/render_workspace_cpu.rs
index 9251f1c1c1..36fa62c94b 100644
--- a/crates/ui-egui/src/render_workspace_cpu.rs
+++ b/crates/ui-egui/src/render_workspace_cpu.rs
@@ -258,6 +258,25 @@ pub(super) fn revalidate(app: &mut SolveApp, name: &str) -> Result<(), String> {
Ok(())
}
+pub(super) fn refresh_render_revision(app: &mut SolveApp) {
+ let mut sources = super::setups::SourceCache::default();
+ let eligible: Vec<String> = app
+ .render_workspace
+ .view
+ .cpu
+ .bindings
+ .iter()
+ .filter(|(name, binding)| sources.same_model_source(app, &binding.document) && target(app, name).as_ref() == Some(&binding.target))
+ .map(|(name, _)| name.clone())
+ .collect();
+ for name in eligible {
+ if let Some(binding) = app.render_workspace.view.cpu.bindings.get_mut(&name) {
+ binding.revision = app.session.revision;
+ binding.document = std::sync::Arc::downgrade(&app.session.doc);
+ }
+ }
+}
+
/// A removed, hidden or ambiguous body never silently becomes a different target.
pub(super) fn set_reflection(app: &mut SolveApp, name: &str, mode: Option<ReflectionMode>) -> Result<(), String> {
let selected = if mode.is_some() { Some(target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?) } else { None };
diff --git a/crates/ui-egui/src/render_workspace_effects.rs b/crates/ui-egui/src/render_workspace_effects.rs
index 1207ded0c3..06851f0ad9 100644
--- a/crates/ui-egui/src/render_workspace_effects.rs
+++ b/crates/ui-egui/src/render_workspace_effects.rs
@@ -74,18 +74,6 @@ pub(super) fn layer_actions(app: &SolveApp, ui: &mut egui::Ui, prefix: &str, sel
(movement, remove)
}
-pub(super) fn aging_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- super::wear::controls(app, ui);
- if app.render_workspace.view.method != ImageMethod::GpuRaytrace {
- return;
- }
- 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");
- super::environment::atmosphere(app, ui);
- });
-}
-
pub(super) fn presentation_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::banner(ui, ui_kit::AssistantTone::Neutral, |ui| note(app, ui, "render.children.effects_banner"));
let enabled = app.render_workspace.view.method == ImageMethod::GpuRaytrace;
diff --git a/crates/ui-egui/src/render_workspace_environment.rs b/crates/ui-egui/src/render_workspace_environment.rs
index 7ffd78ef9e..141ae7a976 100644
--- a/crates/ui-egui/src/render_workspace_environment.rs
+++ b/crates/ui-egui/src/render_workspace_environment.rs
@@ -55,8 +55,7 @@ fn ring_target(app: &SolveApp) -> bool {
let view = &app.render_workspace.view;
super::active(app)
&& !view.result
- && (view.selection == super::RenderSelection::Environment
- || matches!(view.inspector.page, super::inspector::Page::Environment | super::inspector::Page::Background))
+ && view.selection == super::RenderSelection::Environment
&& environment_values(app).is_some_and(|(_, _, _, rotates)| rotates)
&& !app.session.model.is_stale()
}
@@ -268,12 +267,10 @@ pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui) {
}
pub(super) fn open_sources(app: &mut SolveApp) {
- let page = app.render_workspace.view.inspector.page;
super::library::open_category(app, "hdr");
if let Err(error) = app.run("view.render_stage", json!({"stage":Stage::Light.key()})) {
app.set_status(error, true);
}
- app.render_workspace.view.inspector.page = page;
}
fn note(app: &SolveApp, ui: &mut egui::Ui, key: &str) {
diff --git a/crates/ui-egui/src/render_workspace_hdr.rs b/crates/ui-egui/src/render_workspace_hdr.rs
index 30caf28f1e..651894a6d4 100644
--- a/crates/ui-egui/src/render_workspace_hdr.rs
+++ b/crates/ui-egui/src/render_workspace_hdr.rs
@@ -122,9 +122,7 @@ pub(super) fn pick(app: &mut SolveApp, target: Target) {
}
if let Err(error) = inspect(app, target, path) {
app.set_status(error, true);
- } else if app.render_workspace.view.selection == super::RenderSelection::Environment
- || matches!(app.render_workspace.view.inspector.page, super::inspector::Page::Environment | super::inspector::Page::Background)
- {
+ } else if app.render_workspace.view.selection == super::RenderSelection::Environment {
super::environment::persist(app);
}
});
diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs
index b848b9f638..6cc3d98333 100644
--- a/crates/ui-egui/src/render_workspace_inspector_tests.rs
+++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs
@@ -6,6 +6,7 @@ fn fixture() -> Harness {
h.app.run("solid.box", json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap();
super::super::enter(&mut h.app, true).unwrap();
h.app.run("view.render_stage", json!({"stage":"output"})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"output"})).unwrap();
h.frames(3);
h
}
@@ -135,7 +136,7 @@ fn render_workspace_scene_overview_selection_order_links_and_readiness_are_read_
let before = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene);
+ assert_eq!(selected_editor(&h.app), Editor::Scene);
ordered_sections(&["render.scene_stages", "render.scene_ready", "render.scene_reminders"], &h.app);
let mut bottom = f32::NEG_INFINITY;
for id in ["look", "light", "frame", "output"] {
@@ -149,7 +150,7 @@ fn render_workspace_scene_overview_selection_order_links_and_readiness_are_read_
assert!(crate::scenario::rect_of("dialog:note:render.scene_batch_reason").is_some());
h.step(&json!({"click":{"handle":"render:scene:frame"}})).unwrap();
assert!(matches!(h.app.render_workspace.view.selection, super::super::RenderSelection::Shot(_)));
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Camera);
+ assert_eq!(selected_editor(&h.app), Editor::Camera);
h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
h.frames(2);
h.step(&json!({"click":{"handle":"render:scene:output"}})).unwrap();
@@ -157,7 +158,7 @@ fn render_workspace_scene_overview_selection_order_links_and_readiness_are_read_
h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
h.frames(2);
h.step(&json!({"click":{"handle":"render:scene:open-check"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Diagnostics);
+ assert_eq!(selected_editor(&h.app), Editor::Check);
assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Check);
assert!(crate::scenario::rect_of("render:check").is_some());
assert_eq!(h.app.session.doc.to_json(), before);
@@ -174,7 +175,7 @@ fn render_workspace_shot_e7_order_disabled_reasons_output_link_and_confirm_remov
h.app.run("view.render_select", json!({"kind":"shot","id":name})).unwrap();
let before = h.app.session.doc.to_json();
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Camera);
+ assert_eq!(selected_editor(&h.app), Editor::Camera);
assert!(crate::scenario::rect_of("render:job-footer").is_none(), "Shot owns its actions");
assert!(crate::scenario::rect_of("dialog:editor_footer").is_none(), "Appearance footer stays in Appearance");
let inspector = crate::scenario::rect_of("render:inspector").unwrap();
@@ -198,7 +199,7 @@ fn render_workspace_shot_e7_order_disabled_reasons_output_link_and_confirm_remov
assert_eq!(h.app.session.doc.to_json(), before, "cancelling removal keeps the Shot");
h.step(&json!({"click":{"handle":"render:shot:output"}})).unwrap();
assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Output);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output);
+ assert_eq!(selected_editor(&h.app), Editor::Output);
}
#[test]
@@ -253,55 +254,71 @@ fn render_workspace_shot_lens_saves_only_lens_and_orthographic_keeps_faded_contr
assert_eq!(h.app.session.doc.render.setups[name], before, "opening must not change saved intent or method");
}
#[test]
-fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_footer() {
+fn inspector_dispatch_has_one_editor_per_selection_independent_of_every_stage() {
+ use super::super::{RenderSelection, Stage};
for dark in [false, true] {
for layout in [crate::shell::LayoutMode::Docked, crate::shell::LayoutMode::Floating] {
let mut h = fixture();
h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
h.app.ui.layout = layout;
- h.call("ui.resize", json!({"width":1280,"height":900}));
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output);
+ h.call("ui.resize", json!({"width":1440,"height":1000}));
+ super::super::select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
+ super::super::light::edit(&mut h.app, "render.lights.add", None, Some(json!({"kind":"point"}))).unwrap();
+ let light = super::super::light::rows(&h.app).unwrap().last().unwrap().id.clone();
+ let shot = h.app.render_workspace.view.name.clone();
let before = h.app.session.doc.to_json();
- let revision = h.app.session.revision;
- let history = (h.app.session.undo.len(), h.app.session.redo.len());
- for page in Page::ALL {
- h.app.render_workspace.view.inspector.page = page;
- h.frames(3);
- let inspector = crate::scenario::rect_of("render:inspector").unwrap();
- assert_eq!(h.app.session.doc.to_json(), before);
- assert_eq!(h.app.session.revision, revision);
- assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
- assert!(h.app.render_workspace.view.job.is_none());
- assert!(h.app.render_workspace.view.completed.is_none());
- if page == Page::Appearance {
- let footer = crate::scenario::rect_of("dialog:editor_footer").unwrap();
- assert!(inspector.contains_rect(footer), "Appearance footer outside inspector: {inspector:?} {footer:?}");
- assert!(crate::scenario::rect_of("render:job-footer").is_none());
- continue;
- }
- if matches!(page, Page::Output | Page::Effects | Page::Diagnostics | Page::Sampling) {
- 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"] {
- let action = crate::scenario::rect_of(name).unwrap();
- assert!(bar.contains_rect(action), "{name} outside stage bar: {bar:?} {action:?}");
- }
- } else if page == Page::Scene {
- let stages = crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr("render.scene_stages"))).unwrap();
- assert!(inspector.contains_rect(stages), "Scene stages outside inspector: {inspector:?} {stages:?}");
- assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ let undo = (h.app.session.undo.len(), h.app.session.redo.len());
+ for (selection, kind) in [
+ (RenderSelection::Nothing, "scene"),
+ (RenderSelection::Object(vec![solidcraft_engine::Sel::Body { name: "Subject".into() }]), "appearance"),
+ (RenderSelection::Environment, "environment"),
+ (RenderSelection::Lighting, "lighting"),
+ (RenderSelection::Light(light.clone()), "light"),
+ (RenderSelection::Shot(shot.clone()), "shot"),
+ (RenderSelection::Output, "output"),
+ (RenderSelection::Sampling, "sampling"),
+ (RenderSelection::Effects, "effects"),
+ (RenderSelection::Check, "check"),
+ (RenderSelection::Wear, "wear"),
+ ] {
+ if let RenderSelection::Object(_) = &selection {
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: "Subject".into() }]})).unwrap();
} else {
- let footer = crate::scenario::rect_of("render:job-footer").unwrap();
- assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}");
- for name in ["render:check", "render:start", "render:cancel", "render:export"] {
- let target = crate::scenario::rect_of(name).unwrap();
- assert!(footer.contains_rect(target), "{name} clipped at {page:?}");
+ let mut params = json!({"kind":if kind == "scene" { "nothing" } else { kind }});
+ if let RenderSelection::Light(id) | RenderSelection::Shot(id) = &selection {
+ params["id"] = json!(id);
}
+ h.app.run("view.render_select", params).unwrap();
+ }
+ assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), undo);
+ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
+ for stage in Stage::ALL {
+ h.app.run("view.render_stage", json!({"stage":stage.key()})).unwrap();
+ h.frames(3);
+ assert_eq!(h.app.render_workspace.view.selection, selection);
+ let editors = crate::scenario::rects("render:editor:");
+ assert_eq!(editors.len(), 1, "{kind}/{stage:?}: {editors:?}");
+ assert!(crate::scenario::rect_of(&format!("render:editor:{kind}")).is_some());
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ assert!(crate::scenario::rect_of("render:setups").is_none());
+ assert!(crate::scenario::rect_of("render:setup-name").is_none());
+ assert_eq!(crate::scenario::rect_of("render:output-footer").is_some(), kind == "output");
+ assert_eq!(crate::scenario::rect_of("dialog:editor_footer").is_some(), kind == "appearance");
+ assert!(h.widget(h.app.tr("render.studio_title")).is_none());
+ assert_eq!(h.app.render_workspace.view.method, ImageMethod::CpuRaytrace);
+ 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()), history);
+ assert!(h.app.render_workspace.view.job.is_none());
+ assert!(h.app.render_workspace.view.completed.is_none());
+ }
+ if !dark && layout == crate::shell::LayoutMode::Floating {
+ appearance_inspector_capture(&mut h, &format!("dispatch-{kind}"));
}
}
}
}
}
+
#[test]
fn stage_navigation_is_local_and_never_switches_executor_or_overwrites_drafts() {
let mut h = fixture();
@@ -310,7 +327,7 @@ fn stage_navigation_is_local_and_never_switches_executor_or_overwrites_drafts()
h.app.render_workspace.view.draft.width = 777;
for stage in super::super::Stage::ALL {
h.step(&json!({"click":{"handle":format!("render:stage:{}",stage.key())}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, stage.page());
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Output);
assert_eq!(h.app.render_workspace.view.method, ImageMethod::Raster);
assert_eq!(h.app.render_workspace.view.samples, 37);
assert_eq!(h.app.render_workspace.view.draft.width, 777);
@@ -319,32 +336,83 @@ fn stage_navigation_is_local_and_never_switches_executor_or_overwrites_drafts()
}
#[test]
-fn dirty_shot_switch_keep_discard_and_save_are_explicit_and_lossless() {
+fn numerical_editor_saves_before_switch_and_keeps_navigation_camera_explicit() {
let mut h = fixture();
h.app.render_workspace.view.name = "A".into();
setups::save(&mut h.app).unwrap();
h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap();
+ let before = setups::draft(&h.app).unwrap();
+ let camera = before.camera;
h.app.render_workspace.view.draft.width = 123;
- setups::refresh_dirty(&mut h.app);
+ h.app.cam.yaw += 0.25;
+ setups::persist_editor(&mut h.app, &before).unwrap();
+ assert_eq!(h.app.session.doc.render.setups["A"].width, 123);
+ assert_eq!(h.app.session.doc.render.setups["A"].camera, camera);
request_action(&mut h.app, PendingAction::Switch("B".into()));
- h.frames(3);
- h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap();
+ assert!(confirmation_open(&h.app), "persisting width must not silently discard the camera draft");
assert_eq!(h.app.render_workspace.view.name, "A");
- assert_eq!(h.app.render_workspace.view.draft.width, 123);
- request_action(&mut h.app, PendingAction::Switch("B".into()));
h.frames(3);
h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
assert_eq!(h.app.render_workspace.view.name, "B");
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Shot("B".into()));
assert_eq!(h.app.render_workspace.view.draft.width, 321);
- assert_ne!(h.app.session.doc.render.setups["A"].width, 123);
- h.app.render_workspace.view.draft.width = 456;
- setups::refresh_dirty(&mut h.app);
- request_action(&mut h.app, PendingAction::Switch("A".into()));
- h.frames(3);
- h.step(&json!({"widget":h.app.tr("render.save_continue")})).unwrap();
- assert_eq!(h.app.session.doc.render.setups["B"].width, 456);
- assert_eq!(h.app.render_workspace.view.name, "A");
+ assert_eq!(h.app.session.doc.render.setups["A"].width, 123);
}
+
+#[test]
+fn shot_switch_confirms_transient_inputs_and_current_shot_focus_preserves_them() {
+ use solidcraft_engine::render::job::ReflectionMode;
+ for kind in ["glass", "maps", "cpu", "camera"] {
+ let mut h = fixture();
+ h.app.render_workspace.view.name = "A".into();
+ super::super::select_image_method(&mut h.app, if kind == "cpu" { ImageMethod::CpuRaytrace } else { ImageMethod::GpuRaytrace });
+ setups::save(&mut h.app).unwrap();
+ h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap();
+ setups::load(&mut h.app);
+ if kind == "cpu" {
+ super::super::cpu::set_reflection(&mut h.app, "Subject", Some(ReflectionMode::Mirror)).unwrap();
+ } else if kind == "camera" {
+ h.app.cam.yaw += 0.25;
+ } else {
+ let target = materials::read_targets(&mut h.app).unwrap().remove(0);
+ let mut binding = materials::Binding::new(target, &h.app);
+ binding.glass_enabled = kind == "glass";
+ binding.maps_enabled = kind == "maps";
+ h.app.render_workspace.view.materials.enabled = true;
+ h.app.render_workspace.view.materials.bindings.push(binding);
+ }
+ let camera = h.app.cam;
+ let runtime = format!("{:?}", h.app.render_workspace.view.materials);
+ let reflections = h.app.render_workspace.view.raytrace.reflections.clone();
+ let doc = h.app.session.doc.clone();
+ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
+ switch_shot(&mut h.app, "A".into());
+ assert!(!confirmation_open(&h.app), "focusing the current shot must not reload {kind}");
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Shot("A".into()));
+ assert_eq!(format!("{:?}", h.app.render_workspace.view.materials), runtime);
+ assert_eq!(h.app.render_workspace.view.raytrace.reflections, reflections);
+ assert_eq!(h.app.cam, camera);
+ switch_shot(&mut h.app, "B".into());
+ h.frames(3);
+ assert!(confirmation_open(&h.app), "unsaved {kind} must be reviewed");
+ assert_eq!(h.app.render_workspace.view.name, "A");
+ h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap();
+ assert!(!confirmation_open(&h.app));
+ assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
+ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history);
+ assert_eq!(format!("{:?}", h.app.render_workspace.view.materials), runtime);
+ assert_eq!(h.app.render_workspace.view.raytrace.reflections, reflections);
+ assert_eq!(h.app.cam, camera);
+ switch_shot(&mut h.app, "B".into());
+ h.frames(3);
+ h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
+ assert_eq!(h.app.render_workspace.view.name, "B");
+ assert_eq!(h.app.render_workspace.view.draft.width, 321);
+ assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
+ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history);
+ }
+}
+
#[test]
fn expired_confirmation_cannot_remove_a_changed_shot() {
let mut h = fixture();
@@ -711,7 +779,7 @@ fn surface_target_dropdown_keeps_the_chosen_body_through_review() {
fn unsupported_output_is_visible_and_never_fakes_export_or_clamps_intent() {
let mut h = fixture();
super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
- h.app.render_workspace.view.inspector.page = Page::Output;
+ select_editor(&mut h.app, Editor::Output);
h.app.render_workspace.view.draft.width = 7000;
h.app.render_workspace.view.draft.height = 6000;
h.app.render_workspace.view.samples = 37;
@@ -770,7 +838,7 @@ fn actual_output_ratio_is_local_and_orientation_saves_once_preserving_other_capt
h.app.render_workspace.view.draft.width = 1920;
h.app.render_workspace.view.draft.height = 1080;
h.app.render_workspace.view.samples = 37;
- h.app.render_workspace.view.inspector.page = Page::Output;
+ select_editor(&mut h.app, Editor::Output);
setups::save(&mut h.app).unwrap();
let saved = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
@@ -791,7 +859,7 @@ fn actual_output_ratio_is_local_and_orientation_saves_once_preserving_other_capt
expected.height = 1920;
assert_eq!(h.app.session.doc.render.setups[&h.app.render_workspace.view.name], expected);
assert_eq!(h.app.session.undo.len(), undo + 1);
- assert!(h.app.render_workspace.view.dirty);
+ assert!(!h.app.render_workspace.view.dirty, "the numeric edit is already saved");
setups::load(&mut h.app);
h.frames(3);
assert_eq!(h.app.render_workspace.view.inspector.resolution.anchor, Some([1080, 1920]));
@@ -800,7 +868,7 @@ fn actual_output_ratio_is_local_and_orientation_saves_once_preserving_other_capt
#[test]
fn contextual_scope_notes_wrap_with_native_tokens_instead_of_clipping() {
let mut h = fixture();
- h.app.render_workspace.view.inspector.page = Page::Scene;
+ select_editor(&mut h.app, Editor::Scene);
h.frames(3);
let rect = crate::scenario::rect_of("dialog:note:render.scene_preserves_design").unwrap();
let inspector = crate::scenario::rect_of("render:inspector").unwrap();
@@ -909,39 +977,40 @@ fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() {
let doc = h.app.session.doc.to_json();
let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
for (id, page) in [
- ("render.preset.resolve", Page::Scene),
- ("render.settings.get", Page::Scene),
- ("render.library.appearance.apply", Page::Appearance),
- ("render.library.surface.bind", Page::Appearance),
- ("render.library.studio.prepare", Page::Lighting),
- ("render.library.studio.apply", Page::Lighting),
- ("render.library.environment.apply", Page::Environment),
- ("render.stage.backdrop", Page::Background),
- ("render.quality.prepare", Page::Output),
- ("render.status", Page::Diagnostics),
- ("render.camera.get", Page::Camera),
- ("render.camera.set", Page::Camera),
- ("render.preset.apply", Page::Scene),
- ("render.shot.duplicate", Page::Scene),
- ("render.shot.rename", Page::Scene),
- ("render.shot.remove", Page::Scene),
- ("render.optics.bind", Page::Appearance),
- ("render.optics.unbind", Page::Appearance),
- ("render.library.surface.prepare", Page::Appearance),
- ("render.library.surface.unbind", Page::Appearance),
- ("render.library.physical.prepare", Page::Appearance),
- ("render.stage.ground", Page::Background),
- ("render.stage.clear", Page::Background),
- ("render.hdr.inspect", Page::Environment),
- ("render.environment.set", Page::Environment),
- ("render.settings.capture_hdr", Page::Environment),
- ("render.aging.describe", Page::Appearance),
- ("render.effects.describe", Page::Effects),
- ("render.backends", Page::Diagnostics),
+ ("render.preset.resolve", Editor::Scene),
+ ("render.settings.get", Editor::Camera),
+ ("render.library.appearance.apply", Editor::Appearance),
+ ("render.library.surface.bind", Editor::Appearance),
+ ("render.library.studio.prepare", Editor::Lighting),
+ ("render.library.studio.apply", Editor::Lighting),
+ ("render.library.environment.apply", Editor::Environment),
+ ("render.stage.backdrop", Editor::Environment),
+ ("render.quality.prepare", Editor::Sampling),
+ ("render.status", Editor::Check),
+ ("render.camera.get", Editor::Camera),
+ ("render.camera.set", Editor::Camera),
+ ("render.preset.apply", Editor::Scene),
+ ("render.shot.duplicate", Editor::Camera),
+ ("render.shot.rename", Editor::Camera),
+ ("render.shot.remove", Editor::Camera),
+ ("render.optics.bind", Editor::Appearance),
+ ("render.optics.unbind", Editor::Appearance),
+ ("render.library.surface.prepare", Editor::Appearance),
+ ("render.library.surface.unbind", Editor::Appearance),
+ ("render.library.physical.prepare", Editor::Appearance),
+ ("render.stage.ground", Editor::Environment),
+ ("render.stage.clear", Editor::Environment),
+ ("render.hdr.inspect", Editor::Environment),
+ ("render.environment.set", Editor::Environment),
+ ("render.settings.capture_hdr", Editor::Environment),
+ ("render.aging.describe", Editor::Wear),
+ ("render.effects.describe", Editor::Effects),
+ ("render.backends", Editor::Check),
] {
h.app.start(id);
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, page, "{id}");
+ let expected = if matches!(page, Editor::Appearance | Editor::Camera) { Editor::Scene } else { page };
+ assert_eq!(selected_editor(&h.app), expected, "{id}");
assert_eq!(h.app.render_workspace.view.samples, 37);
assert_eq!(h.app.render_workspace.view.draft.width, 777);
assert_eq!(h.app.session.doc.to_json(), doc, "navigation may not execute a parameterless apply");
@@ -1146,7 +1215,7 @@ fn aging_tab_adds_reorders_disables_and_persists_layers_without_engineering_edit
let before = h.app.session.doc.to_json();
h.app.start("render.aging.describe");
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Wear);
assert!(!crate::icon_svg::resolve(solidcraft_engine::find_command("render.aging.describe").unwrap().icon).placeholder);
for code in [1, 3] {
h.step(&json!({"click":{"handle":"render:aging-add"}})).unwrap();
@@ -1162,7 +1231,8 @@ fn aging_tab_adds_reorders_disables_and_persists_layers_without_engineering_edit
h.step(&json!({"click":{"handle":"render:aging-enabled"}})).unwrap();
h.frames(2);
assert!(!h.app.render_workspace.view.studio.aging.get(0).unwrap().enabled);
- assert_eq!(h.app.session.doc.to_json(), before, "editing layers only edits the render draft");
+ assert_ne!(h.app.session.doc.to_json(), before, "Wear saves its stack through render.settings.set");
+ assert_eq!(setups::snapshot(&h.app).unwrap().job, h.app.session.doc.render.setups[&h.app.render_workspace.view.name].job);
let targets = super::super::materials::read_targets(&mut h.app).unwrap();
let identity = targets.iter().find(|target| target.name == "Subject").unwrap().stable_target.clone().unwrap();
h.app.render_workspace.view.studio.aging.get_mut(0).unwrap().target = Some(identity.clone());
@@ -1192,7 +1262,7 @@ fn wear_selection_precedes_output_page_and_appearance_selection_chrome() {
let context = format!(
"layout={:?}, page={:?}, title={title:?}, header={header:?}, pixels_per_point={}",
h.app.ui.layout,
- h.app.render_workspace.view.inspector.page,
+ selected_editor(&h.app),
h.ctx.pixels_per_point(),
);
// egui stores Role::Label text in value(), not label(). Each pass supplies the
@@ -1223,36 +1293,31 @@ fn wear_selection_precedes_output_page_and_appearance_selection_chrome() {
let mut h = fixture();
h.app.ui.layout = layout;
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
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;
+ for stage in super::super::Stage::ALL {
+ h.app.run("view.render_stage", json!({"stage":stage.key()})).unwrap();
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!(crate::scenario::rect_of("render:job-footer").is_none());
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);
+ let output_history = wear_history;
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());
@@ -1260,9 +1325,12 @@ fn wear_selection_precedes_output_page_and_appearance_selection_chrome() {
assert!(crate::scenario::rect_of("render:appearance:close").is_none());
h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
// Clearing semantic focus opens Scene; choose Appearance to test its header recovery.
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene);
- h.app.render_workspace.view.inspector.page = Page::Appearance;
+ assert_eq!(selected_editor(&h.app), Editor::Scene);
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.frames(3);
assert_header(&h, "Subject");
let inspector = crate::scenario::rect_of("render:inspector").unwrap();
@@ -1317,10 +1385,9 @@ fn wear_selection_shows_disabled_controls_with_reason_and_never_changes_method()
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()));
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Wear);
+ assert!(crate::scenario::rect_of("render:wear:controls").is_some());
+ assert!(h.shapes.iter().all(|s| text_color(&s.shape, h.app.tr("render.aging_airborne")).is_none()));
}
#[test]
@@ -1348,8 +1415,14 @@ fn wear_editor_bounds_stale_selection_and_hostile_layer_values_never_panic() {
h.frames(3);
assert_eq!(h.app.render_workspace.view.inspector.effects.selected_aging, 0);
}
+ let model = h.app.session.doc.features.clone();
+ let undo = h.app.session.undo.len();
h.step(&json!({"click":{"handle":"render:aging-remove"}})).unwrap();
assert!(h.app.render_workspace.view.studio.aging.is_empty());
+ let saved = &h.app.session.doc.render.setups[&h.app.render_workspace.view.name];
+ assert!(matches!(&saved.job, Some(solidcraft_engine::doc::render_settings::RenderJob::GpuPath { options, .. }) if options.aging.is_empty()));
+ assert_eq!(h.app.session.doc.features, model);
+ assert_eq!(h.app.session.undo.len(), undo + 1, "removing an invalid layer saves one corrective command");
h.frames(3);
assert!(crate::scenario::rect_of("render:aging-enabled").is_none());
}
@@ -1362,7 +1435,7 @@ fn output_effects_retains_ordered_looks_and_photographic_intent_across_save_and_
let before = h.app.session.doc.to_json();
h.app.start("render.effects.describe");
h.frames(24);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Effects);
+ assert_eq!(selected_editor(&h.app), Editor::Effects);
assert_eq!(h.app.session.doc.to_json(), before, "opening Effects is read-only");
let undo = h.app.session.undo.len();
@@ -1404,7 +1477,7 @@ fn backgrounds_ribbon_exposes_camera_and_physical_options_without_mutating_draft
let revision = h.app.session.revision;
h.app.start("render.stage.backdrop");
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Background);
+ assert_eq!(selected_editor(&h.app), Editor::Environment);
assert_eq!(setups::snapshot(&h.app).unwrap(), draft);
assert_eq!(h.app.session.doc.to_json(), doc);
assert_eq!(h.app.session.revision, revision);
@@ -1442,7 +1515,7 @@ fn clearing_physical_stage_preserves_unsaved_camera_background_and_output_intent
let materials = h.app.session.doc.materials.clone();
h.app.start("render.stage.clear");
h.frames(4);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Background);
+ assert_eq!(selected_editor(&h.app), Editor::Environment);
h.step(&json!({"click":{"handle":"render:stage-clear"}})).unwrap();
h.frames(3);
assert_eq!(h.app.render_workspace.view.draft.stage.len(), 1, "removal needs consent");
@@ -1497,22 +1570,21 @@ fn camera_draft_uses_render_command_and_keeps_saved_design_unchanged() {
}
#[test]
-fn shots_strip_uses_the_existing_dirty_shot_confirmation() {
+fn shots_strip_switch_keeps_numeric_edits_saved_and_opens_the_selected_shot() {
let mut h = fixture();
h.app.render_workspace.view.name = "A".into();
setups::save(&mut h.app).unwrap();
h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap();
+ let before = setups::draft(&h.app).unwrap();
h.app.render_workspace.view.draft.width = 123;
+ setups::persist_editor(&mut h.app, &before).unwrap();
h.frames(3);
h.step(&json!({"click":{"handle":"render:shots:setup:B"}})).unwrap();
- assert!(confirmation_open(&h.app));
- assert_eq!(h.app.render_workspace.view.name, "A");
- h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap();
- assert_eq!(h.app.render_workspace.view.draft.width, 123);
- h.step(&json!({"click":{"handle":"render:shots:setup:B"}})).unwrap();
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
+ assert!(!confirmation_open(&h.app));
assert_eq!(h.app.render_workspace.view.name, "B");
assert_eq!(h.app.render_workspace.view.draft.width, 321);
+ assert_eq!(h.app.session.doc.render.setups["A"].width, 123);
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Shot("B".into()));
}
#[test]
@@ -1745,39 +1817,22 @@ fn shots_strip_render_submits_the_current_job_request() {
}
#[test]
-fn browser_shot_menus_keep_target_and_draft_through_confirmation() {
+fn browser_shot_remove_keeps_confirmation_and_rejects_stale_actions() {
let mut h = fixture();
h.app.render_workspace.view.name = "A".into();
setups::save(&mut h.app).unwrap();
h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap();
- h.app.render_workspace.view.draft.width = 123;
+ let before = h.app.session.doc.to_json();
+ shot_row_action(&mut h.app, "B".into(), "render.shot.remove");
h.frames(3);
- h.step(&json!({"click":{"handle":"render:tree:shot:B"},"button":"right"})).unwrap();
- h.step(&json!({"widget":h.app.tr("render.shot_rename")})).unwrap();
assert!(confirmation_open(&h.app));
- assert_eq!(h.app.render_workspace.view.name, "A");
- h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap();
- assert_eq!(h.app.render_workspace.view.draft.width, 123);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output);
- shot_row_action(&mut h.app, "B".into(), "render.shot.rename");
- h.frames(3);
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
- assert_eq!(h.app.render_workspace.view.name, "B");
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene);
- assert_eq!(h.app.render_workspace.view.draft.width, 321);
- h.app.render_workspace.view.draft.width = 456;
- shot_row_action(&mut h.app, "A".into(), "render.shot.remove");
+ h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();
+ assert_eq!(h.app.session.doc.to_json(), before);
+ shot_row_action(&mut h.app, "B".into(), "render.shot.remove");
h.frames(3);
- assert!(confirmation_open(&h.app));
h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
- assert!(
- !h.app.session.doc.render.setups.contains_key("A"),
- "pending={:?}, status={:?}",
- h.app.render_workspace.view.inspector.pending,
- h.app.status
- );
- assert_eq!(h.app.render_workspace.view.name, "B");
- assert_eq!(h.app.render_workspace.view.draft.width, 456, "removing another shot preserves this draft");
+ assert!(!h.app.session.doc.render.setups.contains_key("B"));
+ assert_eq!(h.app.render_workspace.view.name, "A");
}
#[test]
@@ -1800,6 +1855,10 @@ fn appearance_inspector_targets_and_chain_follow_body_face_and_component() {
.as_u64()
.unwrap() as usize;
h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
let before = h.app.session.doc.to_json();
for (step, present) in [
(ui_kit::LookStep::Face, [true, true, true, true]),
@@ -1828,6 +1887,10 @@ fn appearance_inspector_all_users_replaces_exact_look_once_without_changing_mass
h.app.run("material.assign", json!({"bodies":["Subject","Other"],"material":"Steel"})).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Subject","Other"],"appearance":"ABS - Red"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
let target = targets(&h.app, ui_kit::LookStep::Body);
let from = chains(&mut h.app, &target).unwrap()[0][1].clone().unwrap();
assert_eq!(users(&h.app, &from), 2);
@@ -1844,9 +1907,13 @@ fn appearance_inspector_all_users_replaces_exact_look_once_without_changing_mass
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(users(&h.app, &from), 2);
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
let undo = h.app.session.undo.len();
h.step(&json!({"click":{"handle":format!("dialog:{}:{}", h.app.tr("render.inspector_applies_to"), crate::i18n::format("render.inspector_all_users", &[("count", "2")]))}}))
.unwrap();
@@ -1878,13 +1945,17 @@ fn appearance_inspector_finish_presets_mixed_set_all_and_clear_use_existing_assi
h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Other"],"appearance":"ABS - Blue"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }, Sel::Body { name: "Other".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
let target = targets(&h.app, ui_kit::LookStep::Body);
let looks: Vec<_> = chains(&mut h.app, &target).unwrap().into_iter().map(|c| c[1].clone().unwrap()).collect();
assert!(mixed(&looks, |l| l.color));
assert!(!mixed(&looks, |l| l.opacity));
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
assert!(h.widget(h.app.tr("render.tree_mixed")).is_some());
appearance_inspector_capture(&mut h, "mixed");
let mass = h.app.run("component.properties", json!({})).unwrap();
@@ -1918,9 +1989,13 @@ fn appearance_inspector_real_controls_switch_targets_inspect_chain_and_edit_fini
.as_u64()
.unwrap() as usize;
h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
let before = h.app.session.doc.to_json();
h.step(&json!({"click":{"handle":"render:appearance:chain-menu"}})).unwrap();
h.step(&json!({"click":{"handle":"render:appearance:chain:body"}})).unwrap();
@@ -1948,9 +2023,9 @@ fn appearance_inspector_real_controls_switch_targets_inspect_chain_and_edit_fini
h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_body"))}})).unwrap();
assert_eq!(h.app.session.undo.len(), edited_undo);
appearance_inspector_capture(&mut h, "body");
- h.app.session.selection.clear();
+ h.app.run("select.clear", json!({})).unwrap();
h.frames(3);
- assert!(h.widget(h.app.tr("render.base_appearance")).is_some());
+ assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Nothing);
appearance_inspector_capture(&mut h, "explicit-target");
}
@@ -1963,9 +2038,13 @@ fn appearance_inspector_mixed_fields_are_inert_until_edited_and_accept_the_first
h.app.run("appearance.assign", json!({"bodies":[name],"color":"#123456","opacity":opacity})).unwrap();
}
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }, Sel::Body { name: "Other".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
let before = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
let field = format!("dialog:scalar:{}", h.app.tr("render.inspector_opacity"));
@@ -2002,9 +2081,13 @@ fn appearance_inspector_optical_colour_and_opacity_edits_commit_once_with_shared
)
.unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
let mass = h.app.run("component.properties", json!({})).unwrap();
for (key, text) in [("appearance.metallic", "2"), ("appearance.roughness", "0"), ("render.inspector_opacity", "0.25")] {
let undo = h.app.session.undo.len();
@@ -2044,6 +2127,10 @@ fn appearance_inspector_hex_edits_validate_and_commit_once() {
let mut h = fixture();
h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
let before = h.app.session.doc.to_json();
@@ -2098,6 +2185,10 @@ fn appearance_inspector_shared_picker_preserves_exact_opacity_and_commits_alpha(
let mut h = fixture();
h.app.run("appearance.assign", json!({"bodies":["Subject"],"color":"#abcdef","opacity":0.123456,"appearance":"Tint"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
let mass = h.app.run("component.properties", json!({})).unwrap();
@@ -2148,6 +2239,10 @@ fn appearance_inspector_shared_picker_pbr_rejects_nonopaque_alpha() {
.run("appearance.assign", json!({"bodies":["Subject"],"color":"#123456", "pbr":{"metallic":0.2,"roughness":0.4,"dielectric_ior":1.6}}))
.unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
let before = h.app.session.doc.to_json();
@@ -2179,6 +2274,10 @@ fn appearance_inspector_shared_picker_has_no_outer_hex_editor_and_keeps_mixed_va
h.app.run("appearance.assign", json!({"bodies":[body],"color":color,"opacity":0.123456})).unwrap();
}
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }, Sel::Body { name: "Other".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
let outer = format!("dialog:color_hex:{}", h.app.tr("render.inspector_colour"));
@@ -2222,10 +2321,14 @@ fn appearance_inspector_component_and_face_overrides_remove_to_material_from_rea
.as_u64()
.unwrap() as usize;
h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
super::super::enter(&mut h.app, true).unwrap();
h.frames(2);
h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance);
+ assert_eq!(selected_editor(&h.app), Editor::Appearance);
let mass = h.app.run("component.properties", json!({})).unwrap();
for (step, name) in [("face", "Copper"), ("body", "ABS - Red"), ("component", "ABS - Blue"), ("material", "Steel")] {
let before = h.app.session.doc.to_json();
@@ -2260,15 +2363,22 @@ fn appearance_inspector_capture(h: &mut Harness, name: &str) {
h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
h.app.ui.dark = dark;
h.app.preferences.render_inspector_width = 305.0;
- let ctx = egui::Context::default();
- crate::fonts::setup_bundled_fonts(&ctx);
+ // Texture handles belong to the Harness context. Keep that context and
+ // reupload cached artwork so this CPU renderer has the complete images,
+ // including textures uploaded before evidence recording began.
+ let ctx = h.ctx.clone();
+ crate::icons::clear_texture_cache(&ctx);
+ super::super::library::clear_preview_texture(&mut h.app);
+ let thumbnails = std::mem::take(&mut h.app.render_workspace.thumbnails);
let mut textures = std::collections::HashMap::new();
+ textures.insert(egui::TextureId::default(), ctx.fonts(|fonts| fonts.image()));
+ let start = ctx.input(|input| input.time);
let mut last = None;
for frame in 0..10 {
let mut output = ctx.run_ui(
egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0))),
- time: Some(frame as f64 / 10.0),
+ time: Some(start + (frame + 1) as f64 / 10.0),
focused: true,
..Default::default()
},
@@ -2287,6 +2397,7 @@ fn appearance_inspector_capture(h: &mut Harness, name: &str) {
crop.save(std::path::Path::new(&dir).join(format!("{name}-{}-305.png", if dark { "dark" } else { "light" }))).unwrap();
let image = ui_kit::raster_ui(&ctx, output.shapes, output.pixels_per_point, ctx.content_rect(), &textures);
image.save(std::path::Path::new(&dir).join(format!("{name}-{}.png", if dark { "dark" } else { "light" }))).unwrap();
+ h.app.render_workspace.thumbnails = thumbnails;
}
}
@@ -2299,6 +2410,10 @@ fn appearance_inspector_approved_layout_is_305_wide_and_preserves_stage_bounds()
h.app.run("material.assign", json!({"bodies":["Boss","Subject"],"material":"Steel"})).unwrap();
h.app.run("select.filter", json!({"mode":"body"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Boss".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.preferences.render_inspector_width = 305.0;
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
@@ -2335,6 +2450,10 @@ fn appearance_editor_e2_sections_are_ordered_collapsed_and_expand_for_each_metho
h.call("ui.resize", json!({"width":1440,"height":4000}));
h.app.preferences.render_inspector_width = 308.0;
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
let titles = [
"render.inspector_edit",
@@ -2401,6 +2520,10 @@ fn appearance_editor_e2_sections_are_ordered_collapsed_and_expand_for_each_metho
[Sel::Face { body: "Subject".into(), index: 0, point: solidcraft_engine::geom::Vec3::ZERO }, Sel::Body { name: "Subject".into() }]
{
h.app.session.selection = vec![selection];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
if matches!(h.app.session.selection.first(), Some(Sel::Body { .. })) {
h.app.ui.pick_components = true;
}
@@ -2425,13 +2548,13 @@ fn output_children_select_their_editor_with_all_sections_in_design_order() {
(
"sampling",
RenderSelection::Sampling,
- Page::Sampling,
+ Editor::Sampling,
vec!["render.output_quality", "render.children.path", "render.children.adaptive", "render.children.glass", "render.children.cpu"],
),
(
"effects",
RenderSelection::Effects,
- Page::Effects,
+ Editor::Effects,
vec![
"render.children.tone",
"render.children.looks",
@@ -2443,13 +2566,13 @@ fn output_children_select_their_editor_with_all_sections_in_design_order() {
(
"check",
RenderSelection::Check,
- Page::Diagnostics,
+ Editor::Check,
vec!["render.children.check", "render.children.request", "render.children.renderers", "render.children.under_hood"],
),
(
"output",
RenderSelection::Output,
- Page::Output,
+ Editor::Output,
vec!["render.children.renderer", "render.output_image", "render.output_destination", "render.children.render"],
),
] {
@@ -2468,7 +2591,7 @@ fn output_children_select_their_editor_with_all_sections_in_design_order() {
h.step(&json!({"click":{"handle":handle}})).unwrap();
h.frames(3);
assert_eq!(h.app.render_workspace.view.selection, selection);
- assert_eq!(selected_page(&h.app), page);
+ assert_eq!(selected_editor(&h.app), page);
let mut bottom = 0.0;
for key in sections {
let rect = crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr(key)))
@@ -2501,6 +2624,10 @@ fn appearance_editor_reset_restores_each_picked_saved_look() {
let mut h = fixture();
h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
let saved = h.app.session.doc.appearances.bodies["Subject"].clone();
@@ -2530,6 +2657,10 @@ fn appearance_editor_saved_optics_removal_confirms_and_preserves_other_drafts()
.unwrap();
setups::load(&mut h.app);
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.appearance_editor.saved"))}})).unwrap();
@@ -2569,6 +2700,10 @@ fn appearance_editor_save_optics_keeps_other_temporary_bindings() {
h.app.render_workspace.view.materials.bindings.push(binding);
h.app.render_workspace.view.materials.enabled = true;
h.app.session.selection = vec![Sel::Body { name: "Subject".into() }];
+ {
+ let selection = super::super::object_selection(&h.app);
+ super::super::selection_editor(&mut h.app, &selection);
+ }
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
h.frames(3);
h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.appearance_editor.glass"))}})).unwrap();
@@ -2642,6 +2777,7 @@ fn output_children_hostile_drafts_are_readable_without_normalizing_or_saving() {
#[test]
fn output_children_check_diagnostics_are_collapsed_and_copy_the_current_request() {
let mut h = fixture();
+ setups::save(&mut h.app).unwrap();
h.call("ui.resize", json!({"width":1440,"height":3000}));
h.app.session.set_render_job_host(Some(solidcraft_engine::render::job::CpuHost::cooperative())).unwrap();
h.app.pending_fit = None;
@@ -2688,7 +2824,7 @@ fn output_children_check_diagnostics_are_collapsed_and_copy_the_current_request(
record_check(&mut h.app, &request, &json!({"error":"Exposure exceeds the CPU limit"}));
h.frames(3);
h.step(&json!({"click":{"handle":"render:check:go-to:0"}})).unwrap();
- assert_eq!(selected_page(&h.app), Page::Camera);
+ assert_eq!(selected_editor(&h.app), Editor::Camera);
}
#[test]
@@ -2700,7 +2836,7 @@ fn output_children_focus_survives_clearing_an_object_pick() {
("effects", super::super::RenderSelection::Effects),
("check", super::super::RenderSelection::Check),
] {
- h.app.run("select.set", json!({"bodies":["Subject"]})).unwrap();
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: "Subject".into() }]})).unwrap();
h.app.run("view.render_select", json!({"kind":kind})).unwrap();
assert_eq!(h.app.render_workspace.view.selection, selection);
assert!(h.app.session.selection.is_empty());
diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs
index 12d6a7a3d5..55c26cd297 100644
--- a/crates/ui-egui/src/render_workspace_library.rs
+++ b/crates/ui-egui/src/render_workspace_library.rs
@@ -66,6 +66,11 @@ struct SourcePreview {
sha256: String,
texture: egui::TextureHandle,
}
+
+#[cfg(test)]
+pub(super) fn clear_preview_texture(app: &mut SolveApp) {
+ app.render_workspace.view.library.preview = None;
+}
impl std::fmt::Debug for SourcePreview {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SourcePreview").field("id", &self.id).field("sha256", &self.sha256).finish()
@@ -306,9 +311,8 @@ pub(super) fn open_category(app: &mut SolveApp, kind: &str) {
"quality" | "capabilities" => "output",
_ => "look",
};
- let page = app.render_workspace.view.inspector.page;
let _ = app.run("view.render_stage", json!({"stage":stage}));
- app.render_workspace.view.inspector.page = page;
+
switch_kind(&mut app.render_workspace.view.library, kind);
let view = &mut app.render_workspace.view.library;
view.collection = 0;
@@ -343,14 +347,6 @@ pub(super) fn choose(app: &mut SolveApp, view: &mut View, kind: &str, id: &str)
view.labels.insert(key, display);
view.labels.retain(|key, _| app.preferences.render_library_favorites.contains(key) || app.preferences.render_library_recent.contains(key));
view.statuses.retain(|key, _| app.preferences.render_library_favorites.contains(key) || app.preferences.render_library_recent.contains(key));
- app.render_workspace.view.inspector.page = match kind {
- "native_scenes" | "scenes" | "selene_shots" => super::inspector::Page::Scene,
- "hdr" | "environments" => super::inspector::Page::Environment,
- "rigs" | "lighting" => super::inspector::Page::Lighting,
- "quality" => super::inspector::Page::Output,
- "capabilities" => super::inspector::Page::Diagnostics,
- _ => super::inspector::Page::Appearance,
- };
Ok(())
}
@@ -1272,12 +1268,6 @@ pub(super) fn inspect_kinds(app: &mut SolveApp, ui: &mut egui::Ui, kinds: &[&str
}
}
-pub(super) fn inspect_appearance(app: &mut SolveApp, ui: &mut egui::Ui) {
- if app.render_workspace.view.library.kind == "appearances" {
- inspect(app, ui);
- }
-}
-
/// Interactive command activation can review the specification selected by S5.
pub(super) fn review_selected_quality(app: &mut SolveApp) -> Result<(), String> {
let id = app.render_workspace.view.library.selected.clone().filter(|_| app.render_workspace.view.library.kind == "quality");
@@ -1696,19 +1686,17 @@ mod studio_browser_tests {
h.step(&json!({"click":{"handle":format!("render:library:{id}")}})).unwrap();
h.frames(3);
assert_eq!(h.app.render_workspace.view.library.selected.as_deref(), Some(id.as_str()));
- assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Appearance);
+ assert_eq!(super::super::inspector::selected_editor(&h.app), super::super::inspector::Editor::Scene);
assert_eq!(h.app.session.doc.to_json(), before, "browsing and selection must not apply appearances");
- // The selection-following editor takes precedence; library inspection is
- // available under Advanced when no model target is selected.
+ // Browsing keeps Scene selected until an object is picked.
h.app.run("select.clear", json!({})).unwrap();
h.frames(3);
// Clearing model selection opens Scene overview; inspect the resource again.
h.step(&json!({"click":{"handle":format!("render:library:{id}")}})).unwrap();
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Appearance);
- h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.inspector_advanced"))}})).unwrap();
- h.frames(3);
- h.step(&json!({"widget":h.app.tr("render.library_favorite")})).unwrap();
+ assert_eq!(super::super::inspector::selected_editor(&h.app), super::super::inspector::Editor::Scene);
+ let look = h.app.session.doc.appearances.bodies.get("Sample").unwrap().clone();
+ h.app.run("appearance.favorite", json!({"look":look,"favorite":true})).unwrap();
assert!(h.app.preferences.render_library_favorites.contains(&("appearances".into(), id.clone())));
h.step(&json!({"click":{"handle":"render:library-list"}})).unwrap();
h.frames(3);
@@ -1719,15 +1707,15 @@ mod studio_browser_tests {
assert_eq!(h.app.session.doc.to_json(), before);
let catalog = h.app.run("appearance.library", json!({})).unwrap();
let blue = catalog["appearances"].as_array().unwrap().iter().find(|entry| entry["name"] == "ABS - Blue").unwrap();
- let mut view = std::mem::take(&mut h.app.render_workspace.view.library);
- choose(&mut h.app, &mut view, "appearances", &appearance_id(blue)).unwrap();
- refresh_targets(&mut h.app, &mut view).unwrap();
- view.target = view.targets.first().cloned();
- h.app.render_workspace.view.library = view;
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: "Sample".into() }]})).unwrap();
+ h.app.render_workspace.view.library.collection = 0;
+ h.app.render_workspace.view.library.loaded = false;
h.frames(3);
assert_eq!(h.app.session.doc.to_json(), before);
- h.step(&json!({"widget":h.app.tr("render.library_apply_appearance")})).unwrap();
+ let undo = h.app.session.undo.len();
+ h.step(&json!({"click":{"handle":format!("render:library:{}", appearance_id(blue))}})).unwrap();
assert_eq!(h.app.session.doc.appearances.bodies.get("Sample").unwrap().name, "ABS - Blue");
+ assert_eq!(h.app.session.undo.len(), undo + 1);
if let Some(dir) = std::env::var_os("SOLIDCRAFT_LIBRARY_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
h.app.run("appearance.assign", json!({"bodies":["Sample"],"appearance":"Aluminum - Anodized Blue"})).unwrap();
@@ -2033,9 +2021,9 @@ mod studio_browser_tests {
assert!(h.app.session.undo.is_empty());
choose(&mut h.app, &mut view, "surfaces", "SURF-048").unwrap();
assert_eq!(h.app.preferences.render_library_recent.len(), 32);
- assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Appearance);
+ assert_eq!(super::super::inspector::selected_editor(&h.app), super::super::inspector::Editor::Scene);
choose(&mut h.app, &mut view, "native_scenes", "NATIVE-STUDIO-002").unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Scene);
+ assert_eq!(super::super::inspector::selected_editor(&h.app), super::super::inspector::Editor::Scene);
assert_eq!(h.app.session.doc.to_json(), before);
}
}
diff --git a/crates/ui-egui/src/render_workspace_materials.rs b/crates/ui-egui/src/render_workspace_materials.rs
index 7f2fcd0849..576676ac00 100644
--- a/crates/ui-egui/src/render_workspace_materials.rs
+++ b/crates/ui-egui/src/render_workspace_materials.rs
@@ -18,7 +18,9 @@ use solidcraft_engine::{
},
};
-use crate::{SolveApp, theme::Tokens, ui_kit};
+#[cfg(test)]
+use crate::theme::Tokens;
+use crate::{SolveApp, ui_kit};
const MAX_BINDINGS: usize = 128;
@@ -164,7 +166,9 @@ pub(super) struct View {
pub enabled: bool,
pub bindings: Vec<Binding>,
targets: Vec<Target>,
+ #[cfg(test)]
target: Option<usize>,
+ #[cfg(test)]
target_search: String,
selected: Option<usize>,
target_revision: Option<u64>,
@@ -208,6 +212,30 @@ pub(super) fn revalidate(app: &mut SolveApp, binding: &mut Binding) -> Result<()
Ok(())
}
+/// Render settings may change document identity without changing the reviewed source.
+/// A changed model, material, placement or target still needs explicit revalidation.
+pub(super) fn refresh_render_revision(app: &mut SolveApp) {
+ if app.render_workspace.view.materials.bindings.is_empty() {
+ return;
+ }
+ let Ok(targets) = read_targets(app) else { return };
+ let mut sources = super::setups::SourceCache::default();
+ let eligible: Vec<bool> = app
+ .render_workspace
+ .view
+ .materials
+ .bindings
+ .iter()
+ .map(|binding| sources.same_model_source(app, &binding.document) && targets.contains(&binding.target))
+ .collect();
+ for (binding, eligible) in app.render_workspace.view.materials.bindings.iter_mut().zip(eligible) {
+ if eligible {
+ binding.revision = app.session.revision;
+ binding.document = Arc::downgrade(&app.session.doc);
+ }
+ }
+}
+
/// Called for every Check and Start through the one shared image request builder.
/// No files are read until the engine captures the actual request.
pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> {
@@ -315,6 +343,7 @@ fn vector(app: &SolveApp, ui: &mut egui::Ui, key: &str, values: &mut [f64; 3], r
ui_kit::row(ui, app.tr(key), |ui| ui_kit::vector3_field(ui, values, range, suffix))
}
+#[cfg(test)]
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let title = app.tr("render.material_title").to_string();
ui_kit::section(ui, "render_materials", &title, false, |ui| {
diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_output.rs
similarity index 66%
rename from crates/ui-egui/src/render_workspace_inspector.rs
rename to crates/ui-egui/src/render_workspace_output.rs
index 307729afd1..22decf66f5 100644
--- a/crates/ui-egui/src/render_workspace_inspector.rs
+++ b/crates/ui-egui/src/render_workspace_output.rs
@@ -1,5 +1,5 @@
-//! Contextual native Render UI. One workspace, existing command authority and shared controls.
-//! Page navigation is per document; unsupported backend capabilities never emit dummy parameters.
+//! Output, sampling, checks and shared Render editor adapters.
+//! Unsupported backend capabilities remain visible with a reason.
use super::{ImageMethod, cpu, library, materials, setups, studio};
use crate::{SolveApp, ui_kit};
use serde_json::{Value, json};
@@ -7,100 +7,16 @@ use solidcraft_engine::doc::Document;
use std::sync::{Arc, Weak};
#[path = "render_ui/appearance.rs"]
-mod selection_appearance;
+pub(super) mod selection_appearance;
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub(super) enum Page {
- #[default]
- Scene,
- Appearance,
- Effects,
- Lighting,
- Environment,
- Background,
- Camera,
- Output,
- Sampling,
- Diagnostics,
- #[cfg(test)]
- All,
-}
-impl Page {
- #[cfg(test)]
- const ALL: [Self; 11] = [
- Self::Scene,
- Self::Appearance,
- Self::Lighting,
- Self::Environment,
- Self::Background,
- Self::Camera,
- Self::Effects,
- Self::Output,
- Self::Sampling,
- Self::Diagnostics,
- Self::All,
- ];
- pub(super) fn key(self) -> &'static str {
- match self {
- Self::Scene => "render.page_scene",
- Self::Appearance => "render.page_appearance",
- Self::Effects => "render.page_effects",
- Self::Lighting => "render.page_lighting",
- Self::Environment => "render.page_environment",
- Self::Background => "render.page_background",
- Self::Camera => "render.page_camera",
- Self::Output => "render.page_output",
- Self::Sampling => "render.children.sampling",
- Self::Diagnostics => "render.page_diagnostics",
- #[cfg(test)]
- Self::All => "render.page_all",
- }
- }
- fn handle(self) -> &'static str {
- match self {
- Self::Scene => "scene",
- Self::Appearance => "appearance",
- Self::Effects => "effects",
- Self::Lighting => "lighting",
- Self::Environment => "environment",
- Self::Background => "background",
- Self::Camera => "camera",
- Self::Output => "output",
- Self::Sampling => "sampling",
- Self::Diagnostics => "diagnostics",
- #[cfg(test)]
- Self::All => "all",
- }
- }
- fn icon(self) -> &'static str {
- match self {
- Self::Scene => "render_scene",
- Self::Appearance => "appearance",
- Self::Effects => "camera",
- Self::Lighting => "settings",
- Self::Environment => "environment_map",
- Self::Background => "render_scene",
- Self::Camera => "camera",
- Self::Output => "export",
- Self::Sampling => "settings",
- Self::Diagnostics => "inspect",
- #[cfg(test)]
- Self::All => "list",
- }
- }
-}
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
pub(super) struct View {
pub effects: super::effects::View,
pub hidden: bool,
- pub page: Page,
reveal: Option<&'static str>,
pending: Option<Pending>,
- #[cfg(test)]
- shot_name: String,
pub checked: Option<Review>,
scene_info: Option<Review>,
- appearance: Appearance,
selection_appearance: selection_appearance::View,
pub(super) resolution: Resolution,
}
@@ -166,7 +82,6 @@ struct Pending {
enum PendingAction {
Switch(String),
ManageShot { name: String, command: String },
- Reload,
Remove(String),
}
#[derive(Clone, Debug)]
@@ -181,256 +96,11 @@ impl Review {
self.revision == app.session.revision && Weak::ptr_eq(&self.document, &Arc::downgrade(&app.session.doc))
}
}
-impl Default for View {
- fn default() -> Self {
- Self {
- effects: Default::default(),
- hidden: false,
- page: Page::Scene,
- reveal: None,
- pending: None,
- #[cfg(test)]
- shot_name: String::new(),
- checked: None,
- scene_info: None,
- appearance: Appearance::default(),
- selection_appearance: Default::default(),
- resolution: Resolution::default(),
- }
- }
-}
pub(super) fn record_check(app: &mut SolveApp, request: &Value, reply: &Value) {
app.render_workspace.view.inspector.checked =
Some(Review { request: request.clone(), reply: reply.clone(), revision: app.session.revision, document: Arc::downgrade(&app.session.doc) });
}
-pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
- if app.render_workspace.view.inspector.hidden {
- crate::shell::register_panel(app, "render:inspector", None, None);
- return;
- }
- setups::refresh_dirty(app);
- if app.render_workspace.revision != app.session.revision && !app.render_workspace.view.dirty {
- setups::load(app);
- }
- 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 wear = app.render_workspace.view.selection == super::RenderSelection::Wear;
- let page = selected_page(app);
- let output = !wear && matches!(page, Page::Output | Page::Sampling | Page::Effects | Page::Diagnostics);
- let appearance_editor = !wear && page == Page::Appearance;
- let standalone = !wear && (page == Page::Scene || (page == Page::Camera && super::shot::selected(app).is_some()));
- let selection_appearance = appearance_editor && !app.session.selection.is_empty();
- let title = if wear {
- app.tr("render.wear_title").to_string()
- } else if selection_appearance {
- app.session
- .selection
- .last()
- .and_then(|item| match item {
- solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name.clone()),
- solidcraft_engine::Sel::Occurrence { path } => app.session.occurrence_placement(path).ok().map(|placement| placement.name),
- _ => None,
- })
- .unwrap_or_else(|| app.tr("render.inspector").to_owned())
- } else if standalone {
- super::shot::selected(app).filter(|_| page == Page::Camera).map(str::to_owned).unwrap_or_else(|| app.tr("render.page_scene").to_string())
- } else {
- app.tr(if page == Page::Diagnostics {
- "render.children.check"
- } else if output {
- page.key()
- } else {
- "render.studio_title"
- })
- .to_string()
- };
- 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(
- ui,
- ui_kit::WorkspaceOptions {
- id: "render:inspector",
- title: &title,
- icon,
- bounds,
- fill_height: true,
- compact: crate::render_ui::compact(app, bounds.width()),
- editor: appearance_editor,
- enabled: true,
- header_actions: None,
- },
- &mut side,
- &mut width,
- false,
- |ui, options| {
- if appearance_editor {
- header_action.set(ui_kit::inspector_header(ui, options.icon, options.title, &scope));
- } else {
- ui_kit::panel::header(ui, options.icon, options.title, || header_action.set(Some(ui_kit::InspectorAction::Close)));
- }
- },
- |ui| {
- if output {
- ui_kit::Panel::pinned_footer(ui, "render_output_footer", 1, |ui| {
- ui.horizontal_wrapped(|ui| {
- for (id, label, target) in [
- ("render.start", app.tr("cmd.render_start").to_owned(), "render:output:render"),
- (
- "render.batch",
- crate::i18n::format("render.batch_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]),
- "render:output:all-shots",
- ),
- ] {
- let ready = super::ribbon::action_ready(app, id);
- let response = ui_kit::icon_label_action(ui, &label, Some("play"), ready.is_ok(), id == "render.start");
- let response = if let Err(reason) = ready { response.on_disabled_hover_text(reason) } else { response };
- crate::scenario::publish_target(target, response.rect);
- if response.clicked() {
- app.start(id);
- }
- }
- });
- crate::scenario::publish_rect("render:output-footer", ui.min_rect());
- });
- }
- if !appearance_editor && !output && !standalone {
- header(app, ui);
- ui_kit::Panel::pinned_footer(ui, "render_job_footer", 4, |ui| {
- ui.separator();
- super::job_controls(app, ui, true);
- if ui_kit::button(ui, app.tr("render.return_design"), ui_kit::Button::Normal).clicked()
- && let Err(error) = super::enter(app, false)
- {
- app.set_status(error, true);
- }
- crate::scenario::publish_rect("render:job-footer", ui.min_rect());
- });
- }
- if appearance_editor {
- ui_kit::Panel::editor_footer(ui, "render_appearance_footer", |ui| selection_appearance::footer(app, ui));
- }
- egui::ScrollArea::vertical()
- .max_width(ui.available_width())
- .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 && !standalone {
- ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key()));
- }
- match page {
- Page::Scene => scene_controls(app, ui),
- Page::Appearance => appearance_controls(app, ui),
- Page::Effects => super::effects::output_controls(app, ui),
- Page::Lighting => lighting_controls(app, ui),
- Page::Environment | Page::Background => super::environment::editor(app, ui),
- Page::Camera => {
- if let Some(shot) = super::shot::selected(app).map(str::to_owned) {
- super::shot::editor(app, ui, &shot);
- } else {
- camera_controls(app, ui);
- }
- }
- Page::Output => output_editor(app, ui),
- Page::Sampling => sampling_editor(app, ui),
- Page::Diagnostics => check_editor(app, ui),
- #[cfg(test)]
- Page::All => {
- ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help"));
- shot_controls(app, ui);
- camera_actions(app, ui);
- let title = app.tr("render.page_camera").to_string();
- ui_kit::section(ui, "render_all_camera", &title, false, |ui| camera_controls(app, ui));
- let title = app.tr("render.page_aging").to_string();
- ui_kit::section(ui, "render_all_aging", &title, false, |ui| super::effects::aging_controls(app, ui));
- super::image_edit_controls(app, ui);
- }
- }
- setups::refresh_dirty(app);
- });
- },
- );
- match header_action.get() {
- Some(ui_kit::InspectorAction::Close) => {
- let _ = app.run("view.render_inspector", json!({"visible":false}));
- }
- Some(ui_kit::InspectorAction::Remove) => selection_appearance::remove(app),
- None => {}
- }
- app.preferences.render_inspector_width = width;
- let requested = content
- .as_ref()
- .and_then(|c| c.inner.1)
- .map(str::to_string)
- .or_else(|| (app.preferences.render_inspector_side != side).then(|| side.clone()));
- if let Some(side) = requested {
- let _ = app.run("view.render_dock", serde_json::json!({"panel":"inspector","side":side}));
- }
- let rect = content.map(|c| c.response.rect);
- crate::shell::register_panel(app, "render:inspector", rect, Some(if side == "left" { ui_kit::Edge::Left } else { ui_kit::Edge::Right }));
- if let Some(rect) = rect {
- crate::scenario::publish_rect("render:inspector", rect);
- }
- confirmation(app, ui.ctx());
- library::review::dialog(app, ui.ctx());
- library::review::confirmation(app, ui.ctx());
-}
-fn header(app: &mut SolveApp, ui: &mut egui::Ui) {
- let current = app.render_workspace.view.name.clone();
- let names: Vec<_> = app.session.doc.render.setups.keys().cloned().collect();
- let mut chosen = None;
- let menu = ui_kit::dropdown_menu(ui, "render_setups", &current, |ui| {
- for name in names {
- let r = ui_kit::list_picker(ui, &name, &name, name == current);
- crate::scenario::publish_handle(&format!("render:setup:{name}"), r.rect.center());
- if r.clicked() {
- chosen = Some(name);
- ui.close();
- }
- }
- });
- crate::scenario::publish_target("render:setups", menu.rect);
- if let Some(name) = chosen {
- switch_shot(app, name);
- }
- let field = ui_kit::bounded_cell_editor(ui, ui.id().with("render_setup_name"), &mut app.render_workspace.view.name, "", false, 128);
- crate::scenario::publish_target("render:setup-name", field.rect);
- if field.changed() {
- app.render_workspace.view.dirty = true;
- }
- ui.horizontal_wrapped(|ui| {
- if ui_kit::button(ui, app.tr("render.save_setup"), ui_kit::Button::Enabled(setups::snapshot(app).is_ok())).clicked()
- && let Err(error) = setups::save(app)
- {
- app.set_status(error, true);
- }
- if ui_kit::button(ui, app.tr("render.reload_settings"), ui_kit::Button::Normal).clicked() {
- request_action(app, PendingAction::Reload);
- }
- });
- let status = if app.render_workspace.view.dirty { app.tr("render.unsaved") } else { app.tr("render.studio_saved") };
- ui.add_sized([ui.available_width(), ui.text_style_height(&egui::TextStyle::Body)], egui::Label::new(status).truncate());
- {
- let labels = [app.tr("render.result_preview").to_string(), app.tr("render.result_title").to_string()];
- let mut value = usize::from(app.render_workspace.view.result);
- if ui_kit::segmented(ui, &mut value, &labels.iter().map(String::as_str).collect::<Vec<_>>(), Default::default()) {
- let _ = app.run("render.result.view", json!({"view":if value == 1 {"image"} else {"model"}}));
- }
- }
-}
pub(super) fn switch_shot(app: &mut SolveApp, name: String) {
setups::refresh_dirty(app);
request_action(app, PendingAction::Switch(name));
@@ -446,7 +116,20 @@ pub(super) fn shot_row_action(app: &mut SolveApp, name: String, command: &str) {
}
fn request_action(app: &mut SolveApp, action: PendingAction) {
- if app.render_workspace.view.dirty || matches!(&action, PendingAction::Remove(_)) {
+ // Focusing the current shot is navigation, never a request to reload its draft.
+ if let PendingAction::Switch(name) = &action
+ && *name == app.render_workspace.view.name
+ {
+ super::selection_editor(app, &super::RenderSelection::Shot(name.clone()));
+ return;
+ }
+ setups::refresh_dirty(app);
+ let replaces_draft = match &action {
+ PendingAction::Switch(_) => true,
+ PendingAction::ManageShot { name, .. } => *name != app.render_workspace.view.name,
+ PendingAction::Remove(_) => false,
+ };
+ if (replaces_draft && app.render_workspace.view.dirty) || matches!(&action, PendingAction::Remove(_)) {
app.render_workspace.view.inspector.pending =
Some(Pending { action, document: Arc::downgrade(&app.session.doc), revision: app.session.revision });
} else if let Err(error) = perform_action(app, action) {
@@ -456,16 +139,18 @@ fn request_action(app: &mut SolveApp, action: PendingAction) {
fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), String> {
match action {
PendingAction::Switch(name) => {
- app.render_workspace.view.name = name;
+ app.render_workspace.view.name = name.clone();
setups::load(app);
+ super::selection_editor(app, &super::RenderSelection::Shot(name));
}
PendingAction::ManageShot { name, command } => {
- app.render_workspace.view.name = name;
- setups::load(app);
+ if name != app.render_workspace.view.name {
+ app.render_workspace.view.name = name;
+ setups::load(app);
+ }
// The existing manager owns name validation and command execution.
app.start(&command);
}
- PendingAction::Reload => setups::load(app),
PendingAction::Remove(name) => {
app.run("render.shot.remove", json!({"name":name,"expected_revision":app.session.revision}))?;
if name == app.render_workspace.view.name {
@@ -479,7 +164,7 @@ fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), Strin
}
Ok(())
}
-fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
+pub(super) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
super::shots::confirmation(app, ctx);
materials::confirmation(app, ctx);
super::light::confirmation(app, ctx);
@@ -500,7 +185,7 @@ fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
.actions(&primary, &keep, (!removing).then_some(discard.as_str()))
.selected(ui_kit::Action::Cancel)
.show(ctx, removing || setups::snapshot(app).is_ok(), |ui| {
- ui.label(&message);
+ ui_kit::text(ui, &message, ui_kit::Text::Inline);
});
if closed || answer == ui_kit::Action::Cancel {
app.render_workspace.view.inspector.pending = None;
@@ -526,7 +211,7 @@ fn browse_button(app: &mut SolveApp, ui: &mut egui::Ui, kind: &str, key: &str) {
library::open_category(app, kind);
}
}
-fn scene_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
+pub(super) fn scene_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::text(ui, app.tr("render.scene_preserves_design"), ui_kit::Text::Note("render.scene_preserves_design"));
let label = app.tr("render.children.method").to_string();
ui_kit::row(ui, &label, |ui| super::method_dropdown(app, ui));
@@ -631,75 +316,6 @@ fn scene_stage(app: &mut SolveApp, stage: super::Stage) {
super::Stage::Output => json!({"kind":"output"}),
};
let _ = app.run("view.render_select", params);
- app.render_workspace.view.inspector.page = stage.page();
-}
-#[cfg(test)]
-fn shot_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- let title = app.tr("render.shot_manager").to_string();
- reveal_section(app, ui, "render_shot_manager");
- ui_kit::section(ui, "render_shot_manager", &title, false, |ui| {
- ui_kit::text(ui, app.tr("render.shot_saved_only"), ui_kit::Text::Note("render.shot_saved_only"));
- let label = app.tr("render.shot_new_name").to_string();
- ui_kit::bounded_cell_editor(ui, ui.id().with("render_shot_new_name"), &mut app.render_workspace.view.inspector.shot_name, &label, false, 128);
- for (command, key) in [("render.shot.duplicate", "render.shot_duplicate"), ("render.shot.rename", "render.shot_rename")] {
- let enabled = !app.render_workspace.view.dirty
- && app.session.doc.render.setups.contains_key(&app.render_workspace.view.name)
- && !app.render_workspace.view.inspector.shot_name.trim().is_empty();
- if ui_kit::button(ui, app.tr(key), ui_kit::Button::Enabled(enabled)).clicked() {
- let name = app.render_workspace.view.inspector.shot_name.clone();
- match app.run(command, json!({"name":app.render_workspace.view.name,"new_name":name,"expected_revision":app.session.revision})) {
- Ok(_) => {
- app.render_workspace.view.name = name;
- setups::load(app);
- }
- Err(e) => app.set_status(e, true),
- }
- }
- }
- if ui_kit::button(
- ui,
- app.tr("render.shot_remove"),
- ui_kit::Button::Enabled(app.session.doc.render.setups.contains_key(&app.render_workspace.view.name)),
- )
- .clicked()
- {
- request_action(app, PendingAction::Remove(app.render_workspace.view.name.clone()));
- }
- });
-}
-fn appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- super::assign::selection_controls(app, ui);
- if selection_appearance::controls(app, ui) {
- return;
- }
- library::inspect_appearance(app, ui);
- ui_kit::text(ui, app.tr("render.appearance_physics_separate"), ui_kit::Text::Note("render.appearance_physics_separate"));
- base_appearance(app, ui);
- materials::controls(app, ui);
- let title = app.tr("render.inspector_advanced").to_owned();
- reveal_section(app, ui, "render:appearance:advanced");
- ui_kit::section(ui, "render:appearance:advanced", &title, false, |ui| advanced_appearance_controls(app, ui));
-}
-fn advanced_appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- browse_button(app, ui, "surfaces", "render.browse_surfaces");
- browse_button(app, ui, "physical_profiles", "render.browse_physical");
- library::inspect_kinds(app, ui, &["surfaces", "materials", "selene_appearances", "physical_profiles"]);
- super::effects::aging_controls(app, ui);
-}
-fn lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- if let super::RenderSelection::Light(id) = app.render_workspace.view.selection.clone() {
- super::light::editor(app, ui, &id);
- return;
- }
- super::light::lighting(app, ui);
-}
-fn vector(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, speed: f64) {
- ui.label(label);
- ui.horizontal(|ui| {
- for component in value {
- ui_kit::number_field(ui, component, range.clone(), speed, "");
- }
- });
}
pub(super) fn apply_camera_draft(app: &mut SolveApp, camera: solidcraft_engine::render::Camera) -> Result<(), String> {
app.run("render.camera.set", json!({"camera":camera}))?;
@@ -708,93 +324,78 @@ pub(super) fn apply_camera_draft(app: &mut SolveApp, camera: solidcraft_engine::
Ok(())
}
-fn camera_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- if super::shots::camera_modified(app, &app.render_workspace.view.name) {
- ui_kit::banner(ui, ui_kit::AssistantTone::Warning, |ui| {
- ui_kit::text(ui, app.tr("render.shots_camera_changed"), ui_kit::Text::Note("render.shots_camera_changed"));
- ui.horizontal_wrapped(|ui| {
- let update = ui_kit::primary_button(ui, app.tr("render.shots_update"));
- crate::scenario::publish_target("render:shots:update", update.rect);
- if update.clicked()
- && let Err(error) = super::shots::update_camera(app)
- {
- app.set_status(error, true);
- }
- let revert = ui_kit::button(ui, app.tr("render.shots_revert"), ui_kit::Button::Normal);
- crate::scenario::publish_target("render:shots:revert", revert.rect);
- if revert.clicked()
- && let Err(error) = restore_camera(app)
- {
- app.set_status(error, true);
- }
- });
- });
- }
- ui_kit::text(ui, app.tr("render.camera_exact_help"), ui_kit::Text::Note("render.camera_exact_help"));
- let before = app.cam;
- let mut camera = before;
- let mut perspective = camera.fov > 0.0;
- if ui_kit::checkbox(ui, app.tr("render.perspective"), &mut perspective).changed() {
- // On at the Field of view preference's angle (#5364); a saved setup keeps its own.
- camera.fov = if perspective { crate::prefs::perspective_fov(&app.preferences) } else { 0.0 };
- }
- if perspective {
- let mut fov = camera.fov.to_degrees();
- let label = app.tr("render.camera_fov").to_string();
- if ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut fov, 1.0..=150.0, 0.1, " deg")).changed() {
- camera.fov = fov.to_radians();
- }
- }
- let label = app.tr("render.camera_distance").to_string();
- ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut camera.distance, 0.000001..=1e9, 1.0, " mm"));
- let mut target = [camera.target.x, camera.target.y, camera.target.z];
- vector(ui, app.tr("render.camera_target"), &mut target, -1e9..=1e9, 1.0);
- camera.target = solidcraft_engine::geom::Vec3::new(target[0], target[1], target[2]);
- for (key, value) in [("render.camera_yaw", &mut camera.yaw), ("render.camera_pitch", &mut camera.pitch), ("render.camera_roll", &mut camera.roll)]
- {
- let mut degrees = value.to_degrees();
- let label = app.tr(key).to_string();
- if ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut degrees, -360000.0..=360000.0, 0.5, " deg")).changed() {
- *value = degrees.to_radians();
- }
- }
- if camera != before
- && camera.is_valid()
- && let Err(error) = apply_camera_draft(app, camera)
- {
- app.set_status(error, true);
- }
- camera_actions(app, ui);
- if app.render_workspace.view.method == ImageMethod::GpuRaytrace {
- studio::lens_controls(app, ui);
- }
- editor_section(app, ui, "render_shot_exposure", "render.image_exposure", |app, ui| {
- let enabled = app.render_workspace.view.method != ImageMethod::Raster;
- if !enabled {
- ui_kit::text(ui, app.tr("render.method_limit_raster"), ui_kit::Text::Note("render.method_limit_raster"));
- }
- let label = app.tr("render.image_exposure").to_string();
- ui.add_enabled_ui(enabled, |ui| {
- ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.draft.exposure_ev, -32.0..=32.0, 0.1, " EV"));
- });
- });
- if app.render_workspace.view.result {
- if ui_kit::button(ui, app.tr("render.result_fit"), ui_kit::Button::Normal).clicked() {
- super::fit_result(app);
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Editor {
+ Scene,
+ Appearance,
+ Environment,
+ Wear,
+ Lighting,
+ Light,
+ Camera,
+ Output,
+ Sampling,
+ Effects,
+ Check,
+}
+
+/// Existing fixtures navigate the same selection model as Browser clicks.
+#[cfg(test)]
+pub(super) fn select_editor(app: &mut SolveApp, editor: Editor) {
+ use super::RenderSelection;
+ let selection = match editor {
+ Editor::Appearance => {
+ if app.session.selection.is_empty()
+ && let Some(group) = super::scene::groups(app).first()
+ {
+ app.run(
+ "select.set",
+ json!({"items":group.objects.iter().map(|name| solidcraft_engine::Sel::Body { name: name.clone() }).collect::<Vec<_>>()}),
+ )
+ .unwrap();
+ }
+ super::object_selection(app)
}
- if ui_kit::button(ui, crate::i18n::tr("render.result_actual_size"), ui_kit::Button::Enabled(!super::reduced_display(app))).clicked() {
- app.render_workspace.view.result_scale = super::ResultScale::Actual;
+ Editor::Camera => super::current_shot_selection(app),
+ _ => {
+ let kind = match editor {
+ Editor::Environment => "environment",
+ Editor::Wear => "wear",
+ Editor::Lighting => "lighting",
+ Editor::Output => "output",
+ Editor::Sampling => "sampling",
+ Editor::Effects => "effects",
+ Editor::Check => "check",
+ Editor::Scene => "nothing",
+ Editor::Light | Editor::Appearance | Editor::Camera => panic!("use the exact object, light or shot selection"),
+ };
+ app.run("view.render_select", json!({"kind":kind})).unwrap();
+ return;
}
+ };
+ if let RenderSelection::Shot(name) = &selection {
+ app.run("view.render_select", json!({"kind":"shot","id":name})).unwrap();
+ } else {
+ super::selection_editor(app, &selection);
}
}
-/// The selection owns the editor independently of the active stage.
-fn selected_page(app: &SolveApp) -> Page {
+
+#[cfg(test)]
+pub(super) fn selected_editor(app: &SolveApp) -> Editor {
+ use super::RenderSelection;
match app.render_workspace.view.selection {
- super::RenderSelection::Output => Page::Output,
- super::RenderSelection::Sampling => Page::Sampling,
- super::RenderSelection::Effects => Page::Effects,
- super::RenderSelection::Check => Page::Diagnostics,
- _ => app.render_workspace.view.inspector.page,
+ RenderSelection::Nothing => Editor::Scene,
+ RenderSelection::Object(_) => Editor::Appearance,
+ RenderSelection::Environment => Editor::Environment,
+ RenderSelection::Wear => Editor::Wear,
+ RenderSelection::Lighting => Editor::Lighting,
+ RenderSelection::Light(_) => Editor::Light,
+ RenderSelection::Shot(_) => Editor::Camera,
+ RenderSelection::Output => Editor::Output,
+ RenderSelection::Sampling => Editor::Sampling,
+ RenderSelection::Effects => Editor::Effects,
+ RenderSelection::Check => Editor::Check,
}
}
fn editor_section(app: &mut SolveApp, ui: &mut egui::Ui, id: &'static str, key: &'static str, draw: fn(&mut SolveApp, &mut egui::Ui)) {
@@ -802,7 +403,7 @@ fn editor_section(app: &mut SolveApp, ui: &mut egui::Ui, id: &'static str, key:
let title = app.tr(key).to_string();
ui_kit::section(ui, id, &title, true, |ui| draw(app, ui));
}
-fn output_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
+pub(super) fn output_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
let summary = check_summary(app);
let notes = ui_kit::button(ui, &summary, ui_kit::Button::Normal);
crate::scenario::publish_target("render:output:check", notes.rect);
@@ -1002,7 +603,7 @@ fn render_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let _ = app.run("render.result.view", json!({"view":"image"}));
}
}
-fn sampling_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
+pub(super) fn sampling_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
editor_section(app, ui, "render_sampling_quality", "render.output_quality", |app, ui| {
quality_choices(app, ui);
ui_kit::text(ui, app.tr("render.output_quality_waiting"), ui_kit::Text::Note("render.output_quality_waiting"));
@@ -1063,7 +664,7 @@ fn cpu_sampling(app: &mut SolveApp, ui: &mut egui::Ui) {
*value = reflections;
}
}
-fn check_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
+pub(super) fn check_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
editor_section(app, ui, "render_check_check", "render.children.check", check_controls);
editor_section(app, ui, "render_check_request", "render.children.request", request_controls);
editor_section(app, ui, "render_check_renderers", "render.children.renderers", renderer_status);
@@ -1112,12 +713,15 @@ fn check_note_link(app: &mut SolveApp, ui: &mut egui::Ui, index: usize, line: &C
let response = ui_kit::button(ui, &label, ui_kit::Button::Normal);
crate::scenario::publish_target(&format!("render:check:go-to:{index}"), response.rect);
if response.clicked() {
- let _ = app.run("view.render_select", json!({"kind":kind}));
- if kind == "nothing" {
- app.render_workspace.view.inspector.page = if key == "render.page_camera" { Page::Camera } else { Page::Appearance };
- }
- if kind == "environment" {
- app.render_workspace.view.inspector.page = Page::Environment;
+ if key == "render.page_camera" {
+ let selection = super::current_shot_selection(app);
+ if let super::RenderSelection::Shot(name) = selection {
+ let _ = app.run("view.render_select", json!({"kind":"shot","id":name}));
+ }
+ } else if kind == "nothing" {
+ super::selection_editor(app, &super::object_selection(app));
+ } else {
+ let _ = app.run("view.render_select", json!({"kind":kind}));
}
}
}
@@ -1546,7 +1150,9 @@ fn diagnostics(app: &mut SolveApp, ui: &mut egui::Ui) {
if let Some(check) = &app.render_workspace.view.inspector.checked {
json_details(app, ui, "render.diag_preflight_details", &check.reply);
}
+ cpu::checked_status(app, ui, super::image_params(app).as_ref().ok());
if let Some(job) = job {
+ cpu::captured_status(app, ui, &job);
json_details(app, ui, "render.diag_job_details", &job);
}
for key in
@@ -1571,107 +1177,6 @@ fn json_details(app: &SolveApp, ui: &mut egui::Ui, key: &str, value: &Value) {
ui_kit::read_only_text(ui, &text);
});
}
-#[derive(Clone, Debug)]
-struct Appearance {
- query: String,
- items: Vec<Value>,
- selected: Option<String>,
- document: Option<Weak<Document>>,
- revision: Option<u64>,
- color: [u8; 3],
- metallic: f64,
- roughness: f64,
- ior: f64,
- opaque: bool,
-}
-impl Default for Appearance {
- fn default() -> Self {
- Self {
- query: String::new(),
- items: Vec::new(),
- selected: None,
- document: None,
- revision: None,
- color: [160, 170, 180],
- metallic: 0.0,
- roughness: 0.5,
- ior: 1.5,
- opaque: false,
- }
- }
-}
-fn base_appearance(app: &mut SolveApp, ui: &mut egui::Ui) {
- let title = app.tr("render.base_appearance").to_string();
- ui_kit::section(ui, "render_base_appearance", &title, false, |ui| {
- let mut view = std::mem::take(&mut app.render_workspace.view.inspector.appearance);
- ui_kit::bounded_cell_editor(ui, ui.id().with("render_base_target_search"), &mut view.query, app.tr("render.material_filter"), false, 128);
- if ui_kit::button(ui, app.tr("render.material_refresh"), ui_kit::Button::Normal).clicked() {
- match app.run("render.library.targets", json!({"query":view.query,"limit":128})) {
- Ok(reply) => {
- view.items = reply["items"].as_array().cloned().unwrap_or_default();
- view.selected = None;
- view.document = Some(Arc::downgrade(&app.session.doc));
- view.revision = Some(app.session.revision);
- }
- Err(error) => app.set_status(error, true),
- }
- }
- let label = view.selected.clone().unwrap_or_else(|| app.tr("render.material_choose_body").into());
- ui_kit::dropdown_menu(ui, "render_base_target", &label, |ui| {
- for item in &view.items {
- let Some(name) = item["name"].as_str() else { continue };
- if ui_kit::list_picker(ui, &format!("base:{name}"), name, view.selected.as_deref() == Some(name)).clicked() {
- view.selected = Some(name.into());
- view.color = serde_json::from_value(item["color"].clone()).unwrap_or([160, 170, 180]);
- view.opaque = item["opacity"].as_f64() == Some(1.0);
- view.metallic = item["pbr"]["metallic"].as_f64().unwrap_or(0.0);
- view.roughness = item["pbr"]["roughness"].as_f64().unwrap_or(0.5);
- view.ior = item["pbr"]["dielectric_ior"].as_f64().unwrap_or(1.5);
- ui.close();
- }
- }
- });
- if view.selected.is_some() {
- ui.label(app.tr("render.base_color"));
- ui_kit::color_field(ui, &mut view.color);
- for (key, value, range) in [
- ("render.base_metallic", &mut view.metallic, 0.0..=1.0),
- ("render.material_roughness", &mut view.roughness, 0.045..=1.0),
- ("render.material_ior", &mut view.ior, 1.0..=3.0),
- ] {
- let label = app.tr(key).to_string();
- ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, value, range, 0.01, ""));
- }
- let current = view.revision == Some(app.session.revision)
- && view.document.as_ref().is_some_and(|d| Weak::ptr_eq(d, &Arc::downgrade(&app.session.doc)))
- && !app.session.model.is_stale();
- if !current {
- ui_kit::text(ui, app.tr("render.material_refresh_needed"), ui_kit::Text::Note("render.material_refresh_needed"));
- }
- if !view.opaque {
- ui_kit::text(ui, app.tr("render.base_opaque_only"), ui_kit::Text::Note("render.base_opaque_only"));
- }
- if ui_kit::button(ui, app.tr("render.base_apply"), ui_kit::Button::Enabled(current && view.opaque)).clicked()
- && let Some(name) = &view.selected
- {
- match app.run(
- "appearance.assign",
- json!({"bodies":[name],"color":view.color,"opacity":1.0,
- "pbr":{"metallic":view.metallic,"roughness":view.roughness,"dielectric_ior":view.ior}}),
- ) {
- Ok(_) => {
- view.revision = Some(app.session.revision);
- view.document = Some(Arc::downgrade(&app.session.doc));
- }
- Err(error) => app.set_status(error, true),
- }
- }
- ui_kit::text(ui, app.tr("render.base_apply_help"), ui_kit::Text::Note("render.base_apply_help"));
- }
- app.render_workspace.view.inspector.appearance = view;
- });
-}
-
#[cfg(test)]
#[path = "render_workspace_inspector_tests.rs"]
mod tests;
@@ -1692,21 +1197,6 @@ pub(super) fn restore_camera(app: &mut SolveApp) -> Result<(), String> {
app.follow_view_request(false);
Ok(())
}
-fn camera_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
- ui.horizontal_wrapped(|ui| {
- if ui_kit::button(ui, app.tr("render.fit"), ui_kit::Button::Normal).clicked()
- && let Err(error) = fit_subject(app)
- {
- app.set_status(error, true);
- }
- if ui_kit::button(ui, app.tr("render.restore_camera"), ui_kit::Button::Normal).clicked()
- && let Err(error) = restore_camera(app)
- {
- app.set_status(error, true);
- }
- });
-}
-
pub(super) fn confirmation_open(app: &SolveApp) -> bool {
app.render_workspace.view.inspector.pending.is_some()
|| app.render_workspace.view.save_shot_name.is_some()
@@ -1727,17 +1217,14 @@ fn reveal_section(app: &mut SolveApp, ui: &mut egui::Ui, section: &'static str)
}
fn gpu_status(app: &SolveApp, ui: &mut egui::Ui) {
- if app.render_workspace.view.method != ImageMethod::GpuRaytrace {
- return;
- }
match &app.render_workspace.path_host {
super::PathHost::Preparing(_, started) => super::setup_progress(ui, app, *started),
super::PathHost::Failed(error) => {
ui_kit::text(ui, &format!("{}: {error}", app.tr("render.gpu_path_failed")), ui_kit::Text::Error("render.gpu_path_failed"));
}
- super::PathHost::NotStarted => {
+ super::PathHost::NotStarted if app.render_workspace.view.method == ImageMethod::GpuRaytrace => {
ui_kit::text(ui, app.tr("render.gpu_unavailable"), ui_kit::Text::Note("render.gpu_unavailable"));
}
- super::PathHost::Ready(_) => {}
+ super::PathHost::NotStarted | super::PathHost::Ready(_) => {}
}
}
diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs
index ff8cb4f20f..10a4f76b24 100644
--- a/crates/ui-egui/src/render_workspace_ribbon.rs
+++ b/crates/ui-egui/src/render_workspace_ribbon.rs
@@ -220,17 +220,31 @@ pub(super) fn presentation(app: &SolveApp) -> solidcraft_engine::render::job::pr
}
}
-fn focus(app: &mut SolveApp, page: inspector::Page, category: Option<&str>) {
- app.render_workspace.view.inspector.hidden = false;
- let kind = match page {
- inspector::Page::Sampling => "sampling",
- inspector::Page::Effects => "effects",
- inspector::Page::Diagnostics => "check",
- inspector::Page::Output => "output",
- _ => "nothing",
- };
- let _ = app.run("view.render_select", json!({"kind":kind}));
- app.render_workspace.view.inspector.page = page;
+fn focus(app: &mut SolveApp, selection: super::RenderSelection, category: Option<&str>) {
+ use super::RenderSelection;
+ if matches!(selection, RenderSelection::Object(_)) {
+ // Object shortcuts keep the shared modelling selection.
+ super::selection_editor(app, &selection);
+ } else {
+ let kind = match &selection {
+ RenderSelection::Nothing => "nothing",
+ RenderSelection::Environment => "environment",
+ RenderSelection::Wear => "wear",
+ RenderSelection::Lighting => "lighting",
+ RenderSelection::Light(_) => "light",
+ RenderSelection::Shot(_) => "shot",
+ RenderSelection::Output => "output",
+ RenderSelection::Sampling => "sampling",
+ RenderSelection::Effects => "effects",
+ RenderSelection::Check => "check",
+ RenderSelection::Object(_) => return,
+ };
+ let mut params = json!({"kind":kind});
+ if let RenderSelection::Shot(id) | RenderSelection::Light(id) = &selection {
+ params["id"] = json!(id);
+ }
+ let _ = app.run("view.render_select", params);
+ }
if let Some(category) = category {
library::open_category(app, category);
}
@@ -248,7 +262,7 @@ pub(super) fn start(app: &mut SolveApp, id: &str) -> bool {
return true;
}
// Entering from Design never starts an expensive render with hidden defaults.
- focus(app, inspector::Page::Output, None);
+ focus(app, super::RenderSelection::Output, None);
if is_job_action(id) {
return true;
}
@@ -262,11 +276,12 @@ pub(super) fn start(app: &mut SolveApp, id: &str) -> bool {
fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> {
action_ready(app, id)?;
- use inspector::Page;
+ use super::RenderSelection;
+ let object = super::object_selection(app);
+ let shot = super::current_shot_selection(app);
match id {
"render.aging.describe" => {
- focus(app, Page::Appearance, None);
- inspector::reveal(app, "render:appearance:advanced");
+ let _ = app.run("view.render_select", json!({"kind":"wear"}));
}
"render.compare" => super::compare::start_default(app)?,
"render.result.close" => {
@@ -275,35 +290,34 @@ fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> {
"render.result.view" => {
app.run(id, json!({"view":"image"}))?;
}
- "render.effects.describe" => focus(app, Page::Effects, None),
- "render.preset.resolve" | "render.preset.apply" => focus(app, Page::Scene, Some("native_scenes")),
+ "render.effects.describe" => focus(app, RenderSelection::Effects, None),
+ "render.preset.resolve" | "render.preset.apply" => focus(app, RenderSelection::Nothing, Some("native_scenes")),
"render.settings.get" | "render.shot.duplicate" | "render.shot.rename" | "render.shot.remove" => {
- focus(app, Page::Scene, None);
- inspector::reveal(app, "render_shot_manager");
+ focus(app, shot, None);
}
"render.settings.set" => app.render_workspace.view.save_shot_name = Some(String::new()),
- "render.library.appearance.apply" | "render.optics.bind" | "render.optics.unbind" => focus(app, Page::Appearance, Some("surfaces")),
+ "render.library.appearance.apply" | "render.optics.bind" | "render.optics.unbind" => focus(app, object, Some("surfaces")),
"render.library.surface.bind" | "render.library.surface.prepare" | "render.library.surface.unbind" => {
- focus(app, Page::Appearance, Some("surfaces"));
+ focus(app, object, Some("surfaces"));
}
- "render.library.physical.prepare" => focus(app, Page::Appearance, Some("physical_profiles")),
- "render.library.studio.prepare" => focus(app, Page::Lighting, Some("rigs")),
- "render.library.studio.apply" => focus(app, Page::Lighting, None),
- "render.library.environment.apply" => focus(app, Page::Environment, Some("hdr")),
- "render.environment.set" | "render.hdr.inspect" | "render.settings.capture_hdr" => focus(app, Page::Environment, None),
- "render.stage.backdrop" => focus(app, Page::Background, None),
+ "render.library.physical.prepare" => focus(app, object, Some("physical_profiles")),
+ "render.library.studio.prepare" => focus(app, RenderSelection::Lighting, Some("rigs")),
+ "render.library.studio.apply" => focus(app, RenderSelection::Lighting, None),
+ "render.library.environment.apply" => focus(app, RenderSelection::Environment, Some("hdr")),
+ "render.environment.set" | "render.hdr.inspect" | "render.settings.capture_hdr" => focus(app, RenderSelection::Environment, None),
+ "render.stage.backdrop" => focus(app, RenderSelection::Environment, None),
"render.stage.ground" | "render.stage.clear" => {
- focus(app, Page::Background, None);
+ focus(app, RenderSelection::Environment, None);
inspector::reveal(app, "render_ground_details");
}
"render.settings.apply" => inspector::restore_camera(app)?,
"render.camera.fit" => inspector::fit_subject(app)?,
- "render.camera.get" | "render.camera.set" => focus(app, Page::Camera, None),
+ "render.camera.get" | "render.camera.set" => focus(app, shot, None),
"render.quality.prepare" => {
- focus(app, Page::Output, Some("quality"));
+ focus(app, RenderSelection::Sampling, Some("quality"));
library::review_selected_quality(app)?;
}
- "render.status" | "render.backends" => focus(app, Page::Diagnostics, None),
+ "render.status" | "render.backends" => focus(app, RenderSelection::Check, None),
_ => return Err(crate::i18n::tr("render.error_interactive_command").into()),
}
Ok(())
diff --git a/crates/ui-egui/src/render_workspace_setups.rs b/crates/ui-egui/src/render_workspace_setups.rs
index 6c323ef991..1f88a04f6e 100644
--- a/crates/ui-egui/src/render_workspace_setups.rs
+++ b/crates/ui-egui/src/render_workspace_setups.rs
@@ -50,7 +50,7 @@ pub(super) fn snapshot(app: &SolveApp) -> Result<RenderSetup, String> {
// Compare editable numerical intent before validation, so an incompatible legacy value
// or a lens temporarily paired with an orthographic camera cannot disable dirty tracking.
-fn draft(app: &SolveApp) -> Result<RenderSetup, String> {
+pub(super) fn draft(app: &SolveApp) -> Result<RenderSetup, String> {
let view = &app.render_workspace.view;
let mut setup = RenderSetup { camera: app.cam, ..view.draft.clone() };
setup.job = Some(match view.method {
@@ -140,10 +140,66 @@ fn draft(app: &SolveApp) -> Result<RenderSetup, String> {
Ok(setup)
}
+/// Save only fields a numerical editor changed. Navigation keeps its explicit
+/// Update shot/Revert flow, and temporary optical bindings remain local.
+pub(super) fn persist_editor(app: &mut SolveApp, before: &RenderSetup) -> Result<(), String> {
+ let after = draft(app)?;
+ // A corrective edit (for example removing an invalid wear layer) must not
+ // require the hostile previous draft to be serialisable. The new value and
+ // the saved command are still validated normally.
+ let old = serde_json::to_value(before).ok();
+ let new = serde_json::to_value(&after).map_err(|error| error.to_string())?;
+ let saved = app.session.doc.render.setups.get(&app.render_workspace.view.name);
+ let saved = saved.and_then(|setup| serde_json::to_value(setup).ok());
+ let mut patch = serde_json::Map::new();
+ if let Some(fields) = new.as_object() {
+ for (key, value) in fields {
+ if key != "camera"
+ && old.as_ref().and_then(|old| old.get(key)) != Some(value)
+ && saved.as_ref().and_then(|saved| saved.get(key)) != Some(value)
+ {
+ patch.insert(key.clone(), value.clone());
+ }
+ }
+ }
+ if !patch.is_empty() {
+ after.validate().map_err(|error| error.to_string())?;
+ let name = app.render_workspace.view.name.clone();
+ app.run("render.settings.set", serde_json::json!({"name":name,"set":patch}))?;
+ app.render_workspace.revision = app.session.revision;
+ let camera = app.render_workspace.view.clean_setup.as_ref().map_or(after.camera, |clean| clean.camera);
+ app.render_workspace.view.clean_setup = Some(RenderSetup { camera, ..after.clone() });
+ app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
+ materials::refresh_render_revision(app);
+ cpu::refresh_render_revision(app);
+ }
+ if let Some(saved) = app.session.doc.render.setups.get(&app.render_workspace.view.name) {
+ let mut saved = saved.clone();
+ saved.camera = after.camera;
+ if saved == after {
+ let camera = app.render_workspace.view.clean_setup.as_ref().map_or(after.camera, |clean| clean.camera);
+ app.render_workspace.view.clean_setup = Some(RenderSetup { camera, ..after });
+ app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
+ app.render_workspace.revision = app.session.revision;
+ }
+ }
+ refresh_dirty(app);
+ Ok(())
+}
+
/// A setup switch/reload replaces its numeric editor draft, never a completed image or camera.
pub(super) fn load(app: &mut SolveApp) {
let setup = app.session.doc.render.setups.get(&app.render_workspace.view.name).cloned().unwrap_or_default();
- let view = &mut app.render_workspace.view;
+ load_values(&mut app.render_workspace.view, setup);
+ app.render_workspace.view.dirty = false;
+ app.render_workspace.revision = app.session.revision;
+ // Keep the explicit Restore Saved Camera action: loading options does not navigate.
+ app.render_workspace.view.clean_setup = draft(app).ok();
+ app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
+ super::light::loaded(app);
+}
+
+fn load_values(view: &mut super::ViewState, setup: RenderSetup) {
view.method = ImageMethod::Raster;
view.transparent = false;
view.raytrace = RaytraceOptions::default();
@@ -230,18 +286,193 @@ pub(super) fn load(app: &mut SolveApp) {
None => {}
}
view.draft = setup;
- view.dirty = false;
+}
+
+/// Compare the complete authoring source, excluding only saved Render settings.
+/// Stable body labels alone do not prove that geometry or its material is unchanged.
+pub(super) fn same_model_source(app: &SolveApp, document: &std::sync::Weak<solidcraft_engine::doc::Document>) -> bool {
+ if app.session.model.is_stale() {
+ return false;
+ }
+ let Some(source) = document.upgrade() else { return false };
+ // Exhaustive by design: adding a Document field must update this comparison.
+ // Match ergonomics bind references, including vectors and point-cloud data.
+ macro_rules! compare_authoring_fields {
+ ($($field:ident),* $(,)?) => {{
+ let solidcraft_engine::doc::Document { render: _, $($field),* } = source.as_ref();
+ true $(&& $field == &app.session.doc.$field)*
+ }};
+ }
+ compare_authoring_fields!(
+ format,
+ format_pending,
+ name,
+ units,
+ metadata,
+ params,
+ text_params,
+ features,
+ marker,
+ next_id,
+ reserved_body_names,
+ components,
+ next_component_color_index,
+ occurrences,
+ assembly,
+ sheet,
+ plastic,
+ parts,
+ links,
+ configs,
+ favorites,
+ canvases,
+ point_clouds,
+ param_comments,
+ materials,
+ print_faces,
+ user_materials,
+ appearances,
+ body_components,
+ body_offsets,
+ browser_groups,
+ timeline_groups,
+ browser_order,
+ named_views,
+ visibility,
+ )
+}
+
+/// A single refresh's source comparisons. Targets are still checked per binding.
+#[derive(Default)]
+pub(super) struct SourceCache(Vec<(std::sync::Weak<solidcraft_engine::doc::Document>, bool)>);
+
+impl SourceCache {
+ pub(super) fn same_model_source(&mut self, app: &SolveApp, document: &std::sync::Weak<solidcraft_engine::doc::Document>) -> bool {
+ if let Some((_, same)) = self.0.iter().find(|(source, _)| std::sync::Weak::ptr_eq(source, document)) {
+ return *same && !app.session.model.is_stale() && document.upgrade().is_some();
+ }
+ let same = same_model_source(app, document);
+ self.0.push((document.clone(), same));
+ same
+ }
+}
+
+/// Synchronize saved edits/Undo without replacing local camera or runtime inputs.
+pub(super) fn sync_revision(app: &mut SolveApp) {
+ if app.render_workspace.revision == app.session.revision {
+ return;
+ }
+ // A new shot name can intentionally carry the unsaved draft of its source.
+ // Its missing saved entry is not an Undo of that source's numerical fields.
+ if app.render_workspace.view.clean_name != app.render_workspace.view.name {
+ if !app.render_workspace.view.dirty {
+ load(app);
+ }
+ return;
+ }
+ let Some(clean) = app.render_workspace.view.clean_setup.clone() else {
+ if !app.render_workspace.view.dirty {
+ load(app);
+ }
+ return;
+ };
+ let saved = app.session.doc.render.setups.get(&app.render_workspace.view.name).cloned().unwrap_or_default();
+ let mut previous = super::ViewState::default();
+ load_values(&mut previous, clean.clone());
+ let mut updated = super::ViewState::default();
+ load_values(&mut updated, saved);
+ // Construct the new clean numerical baseline independently of local drafts.
+ let current = std::mem::replace(&mut app.render_workspace.view, updated);
+ let mut next_clean = draft(app).ok();
+ if let Some(next) = &mut next_clean {
+ next.camera = clean.camera;
+ }
+ let updated = std::mem::replace(&mut app.render_workspace.view, current);
+ let view = &mut app.render_workspace.view;
+ macro_rules! sync {
+ ($($head:ident $(.$tail:ident)*),* $(,)?) => {$(
+ if previous.$head$(.$tail)* != updated.$head$(.$tail)* && view.$head$(.$tail)* == previous.$head$(.$tail)* {
+ view.$head$(.$tail)* = updated.$head$(.$tail)*;
+ }
+ )*};
+ }
+ // Only persisted fields participate. Reflections, optical bindings, file selectors,
+ // editor selection, results and host/job state stay in their existing owners.
+ sync!(
+ method,
+ transparent,
+ samples,
+ max_depth,
+ seed,
+ draft.backend,
+ draft.mode,
+ draft.width,
+ draft.height,
+ draft.format,
+ draft.exposure_ev,
+ draft.environment_rotation,
+ draft.environment_intensity,
+ draft.background,
+ draft.job,
+ draft.surfaces,
+ draft.optics,
+ draft.stage,
+ raytrace.budget,
+ raytrace.primary_samples,
+ raytrace.progressive,
+ raytrace.preset,
+ raytrace.lights,
+ raytrace.punctual_lights,
+ raytrace.area_lights,
+ raytrace.area_samples,
+ raytrace.seed,
+ raytrace.shadows,
+ cpu.environment,
+ cpu.color,
+ cpu.intensity,
+ cpu.rotation_rad,
+ cpu.samples,
+ studio.aging,
+ studio.nested_media,
+ studio.volume,
+ studio.adaptive,
+ studio.transmission_samples,
+ studio.finishing,
+ studio.backdrop_enabled,
+ studio.backdrop,
+ studio.linear_exr,
+ studio.tone_map,
+ studio.denoise,
+ studio.lens_enabled,
+ studio.lens,
+ studio.lighting_enabled,
+ studio.ambient,
+ studio.sun_enabled,
+ studio.sun,
+ studio.area_lights,
+ studio.environment,
+ studio.gradient,
+ studio.rotation_rad,
+ studio.intensity,
+ studio.assume_linear_srgb
+ );
+ // File HDR selectors are runtime inputs; embedded selectors follow saved Undo.
+ if view.cpu.hdr == previous.cpu.hdr {
+ view.cpu.hdr = updated.cpu.hdr;
+ }
+ if view.studio.hdr == previous.studio.hdr {
+ view.studio.hdr = updated.studio.hdr;
+ }
+ view.clean_setup = next_clean;
app.render_workspace.revision = app.session.revision;
- // Keep the existing explicit Restore Saved Camera action: loading options does not navigate.
- app.render_workspace.view.clean_setup = draft(app).ok();
- super::light::loaded(app);
+ materials::refresh_render_revision(app);
+ cpu::refresh_render_revision(app);
+ refresh_dirty(app);
}
pub(super) fn refresh_dirty(app: &mut SolveApp) {
- if let Some(clean) = &app.render_workspace.view.clean_setup
- && (has_runtime_inputs(app) || draft(app).as_ref() != Ok(clean))
- {
- app.render_workspace.view.dirty = true;
+ if let Some(clean) = &app.render_workspace.view.clean_setup {
+ app.render_workspace.view.dirty = has_runtime_inputs(app) || draft(app).as_ref() != Ok(clean);
}
}
@@ -284,6 +515,7 @@ pub(super) fn save(app: &mut SolveApp) -> Result<(), String> {
}
app.render_workspace.view.draft = setup.clone();
app.render_workspace.view.clean_setup = Some(setup);
+ app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
app.render_workspace.view.dirty = false;
app.render_workspace.revision = app.session.revision;
Ok(())
diff --git a/crates/ui-egui/src/render_workspace_shot.rs b/crates/ui-egui/src/render_workspace_shot.rs
index 23a2f57119..4331f50038 100644
--- a/crates/ui-egui/src/render_workspace_shot.rs
+++ b/crates/ui-egui/src/render_workspace_shot.rs
@@ -266,7 +266,6 @@ pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str) {
crate::scenario::publish_target("render:shot:output", response.rect);
if response.clicked() {
let _ = app.run("view.render_select", json!({"kind":"output"}));
- app.render_workspace.view.inspector.page = inspector::Page::Output;
}
});
});
@@ -451,9 +450,7 @@ pub(super) fn frame_rect(aspect: f64, viewport: Rect) -> Option<Rect> {
}
pub(crate) fn overlay_visible(app: &SolveApp) -> bool {
- !app.render_workspace.view.result
- && (app.render_workspace.view.stage == Stage::Frame
- || (app.render_workspace.view.inspector.page == inspector::Page::Camera && selected(app).is_some()))
+ !app.render_workspace.view.result && (app.render_workspace.view.stage == Stage::Frame || selected(app).is_some())
}
pub(crate) fn preview_rect(app: &SolveApp, viewport: Rect) -> Option<Rect> {
diff --git a/crates/ui-egui/src/render_workspace_shots.rs b/crates/ui-egui/src/render_workspace_shots.rs
index 48fe8b1cea..e42de977ba 100644
--- a/crates/ui-egui/src/render_workspace_shots.rs
+++ b/crates/ui-egui/src/render_workspace_shots.rs
@@ -9,13 +9,6 @@ pub(super) fn camera_modified(app: &SolveApp, name: &str) -> bool {
app.session.doc.render.setups.get(name).is_some_and(|setup| setup.camera != app.cam)
}
-/// Update just the saved camera, preserving all the shot's other saved intent.
-pub(super) fn update_camera(app: &mut SolveApp) -> Result<(), String> {
- let name = app.render_workspace.view.name.clone();
- app.run("render.settings.set", json!({"name":name,"set":{"camera":app.cam}}))?;
- Ok(())
-}
-
pub(crate) fn contents(app: &mut SolveApp, ui: &mut egui::Ui) {
super::thumbnails::refresh(app, ui.ctx());
let status = app.render_workspace.view.job.and_then(|job| app.session.render_job_handle(job).ok()).and_then(|handle| handle.status().ok());
diff --git a/crates/ui-egui/src/render_workspace_studio.rs b/crates/ui-egui/src/render_workspace_studio.rs
index 47c5a5f255..9f829cd9f1 100644
--- a/crates/ui-egui/src/render_workspace_studio.rs
+++ b/crates/ui-egui/src/render_workspace_studio.rs
@@ -164,6 +164,7 @@ pub(super) fn tone_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
}
}
+#[cfg(test)]
pub(super) fn lens_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let lens = app.tr("render.studio_lens").to_string();
ui_kit::checkbox(ui, &lens, &mut app.render_workspace.view.studio.lens_enabled);
diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs
index 42703667a4..c87b662a7f 100644
--- a/crates/ui-egui/src/render_workspace_tests.rs
+++ b/crates/ui-egui/src/render_workspace_tests.rs
@@ -3,6 +3,14 @@ use crate::scenario::Harness;
use egui::Color32;
use solidcraft_engine::Session;
+fn click_render_check(h: &mut Harness) {
+ h.app.run("view.render_select", json!({"kind":"check"})).unwrap();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"render:check"}})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"output"})).unwrap();
+ h.frames(3);
+}
+
fn environment_editor_frame(h: &mut Harness, events: Vec<egui::Event>) {
let mut output = h.ctx.run_ui(
egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 1800.0))), events, ..Default::default() },
@@ -275,7 +283,7 @@ fn environment_ring_frame(h: &mut Harness, mods: egui::Modifiers, events: Vec<eg
fn environment_ring_fixture() -> Harness {
let mut h = environment_editor_fixture();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::Environment;
+ inspector::select_editor(&mut h.app, inspector::Editor::Environment);
h.app.preferences.nav = crate::prefs::OPENSCAD_NAV.into();
h.app.cam.fit(&solidcraft_engine::product_scene::extract(&h.app.session).unwrap().bounds);
environment_ring_frame(&mut h, egui::Modifiers::NONE, vec![]);
@@ -407,14 +415,14 @@ fn environment_ring_cancel_or_stale_revision_discards_the_drag() {
#[test]
fn environment_ring_visibility_follows_editor_target_and_live_canvas() {
let mut h = environment_ring_fixture();
- h.app.render_workspace.view.inspector.page = inspector::Page::Lighting;
+ inspector::select_editor(&mut h.app, inspector::Editor::Lighting);
h.app.render_workspace.view.selection = RenderSelection::Environment;
environment_ring_frame(&mut h, egui::Modifiers::NONE, vec![]);
assert!(h.app.render_workspace.view.environment_ring.geometry.is_some());
h.app.render_workspace.view.selection = RenderSelection::Nothing;
environment_ring_frame(&mut h, egui::Modifiers::NONE, vec![]);
assert!(h.app.render_workspace.view.environment_ring.geometry.is_none());
- h.app.render_workspace.view.inspector.page = inspector::Page::Environment;
+ inspector::select_editor(&mut h.app, inspector::Editor::Environment);
h.app.render_workspace.view.result = true;
environment_ring_frame(&mut h, egui::Modifiers::NONE, vec![]);
assert!(h.app.render_workspace.view.environment_ring.geometry.is_none());
@@ -425,15 +433,16 @@ fn environment_editor_opening_pages_and_sources_preserves_design_and_history() {
let mut h = environment_editor_fixture();
let before = h.app.session.doc.clone();
let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
- for page in [inspector::Page::Environment, inspector::Page::Background] {
- h.app.render_workspace.view.inspector.page = page;
+ {
+ let page = inspector::Editor::Environment;
+ inspector::select_editor(&mut h.app, page);
environment_editor_frame(&mut h, vec![]);
assert!(crate::scenario::rect_of("render:environment:rotation-slider").is_some());
h.app.ui.show_browser = false;
environment::open_sources(&mut h.app);
assert!(h.app.ui.show_browser);
assert_eq!(h.app.render_workspace.view.stage, Stage::Light);
- assert_eq!(h.app.render_workspace.view.inspector.page, page);
+ assert_eq!(inspector::selected_editor(&h.app), page);
assert!(Arc::ptr_eq(&before, &h.app.session.doc));
assert_eq!(history, (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()));
}
@@ -565,8 +574,10 @@ fn render_workspace_frame_guides_are_transient_and_overlay_visibility_is_context
let frame = shot::preview_rect(&h.app, viewport).unwrap();
assert!((frame.width() / frame.height() - 16.0 / 9.0).abs() < 0.001);
h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
+ assert!(shot::overlay_visible(&h.app), "a stage change keeps the selected Shot");
+ h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
assert!(!shot::overlay_visible(&h.app));
- h.app.render_workspace.view.inspector.page = inspector::Page::Camera;
+ h.app.run("view.render_select", json!({"kind":"shot","id":"Hero"})).unwrap();
assert!(shot::overlay_visible(&h.app));
h.app.render_workspace.view.result = true;
assert!(!shot::overlay_visible(&h.app));
@@ -746,7 +757,6 @@ fn render_lights_editor_opening_and_disabled_gpu_types_never_edit_or_start_a_job
.unwrap();
setups::load(&mut h.app);
h.app.run("view.render_select", json!({"kind":"light","id":"area:0"})).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::Lighting;
let document = h.app.session.doc.clone();
let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision, h.app.session.is_dirty());
h.frames(3);
@@ -808,7 +818,7 @@ fn render_lights_list_inspects_unsaved_ui_draft_without_applying_or_opening_anyt
let document = h.app.session.doc.clone();
let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision, h.app.session.is_dirty());
let camera = h.app.cam;
- let page = h.app.render_workspace.view.inspector.page;
+ let page = inspector::selected_editor(&h.app);
let snapshot = setups::snapshot(&h.app).unwrap();
let reply = h.app.run("render.lights.list", json!({"settings":snapshot})).unwrap();
assert_eq!(reply["lights"].as_array().unwrap().len(), 1);
@@ -819,7 +829,7 @@ fn render_lights_list_inspects_unsaved_ui_draft_without_applying_or_opening_anyt
assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision, h.app.session.is_dirty()));
assert_eq!(h.app.cam, camera);
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Environment);
- assert_eq!(h.app.render_workspace.view.inspector.page, page);
+ assert_eq!(inspector::selected_editor(&h.app), page);
assert_eq!(setups::snapshot(&h.app).unwrap(), snapshot);
assert!(h.app.render_workspace.view.job.is_none());
assert!(h.app.dialog.is_none() && h.app.tool.is_none());
@@ -853,7 +863,7 @@ mod async_path_host {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":1600}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
h
}
@@ -1004,7 +1014,7 @@ mod async_path_host {
crate::documents::adopt(&mut h.app, Session::default());
assert!(matches!(h.app.render_workspace.path_host, PathHost::Preparing(..)));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
assert!(h.widget("GPU path tracer: compiling shaders…").is_some());
enter(&mut h.app, false).unwrap();
@@ -1012,7 +1022,7 @@ mod async_path_host {
finish_setup(&mut h);
assert!(matches!(h.app.render_workspace.path_host, PathHost::Ready(_)));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
assert!(h.widget("GPU path tracer: compiling shaders…").is_none());
assert!(image_host(&h.app, ImageMethod::GpuRaytrace).is_ok());
@@ -1086,7 +1096,7 @@ mod async_path_host {
completed_preview(&mut h, [200, 210, 220]);
crate::documents::adopt(&mut h.app, Session::default());
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
assert!(h.widget(message).is_some());
h.app.render_workspace.path_host.start(|| panic!("failed setup retried on viewport install"));
@@ -1263,7 +1273,7 @@ fn adopting_into_blank_document_resets_render_draft_and_preserves_hosts() {
sync_backend(&mut h.app);
h.app.render_workspace.view.name = "Old draft".into();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
let mut incoming = Session::default();
incoming.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap();
crate::documents::adopt(&mut h.app, incoming);
@@ -1280,20 +1290,19 @@ fn clicked_image_controls_complete_cancel_and_export_without_dirtying_the_design
let mut h = Harness::new();
h.app.preferences.language = language.into();
h.frames(1);
- let check = h.app.tr("cmd.render_preflight").to_string();
- let start = h.app.tr("render.image_start").to_string();
- let export = h.app.tr("render.image_export").to_string();
+
+ let export = studio::export_label(&h.app).to_string();
h.call("ui.resize", json!({"width":1600,"height":1400}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.render_workspace.view.draft.width = 16;
h.app.render_workspace.view.draft.height = 16;
h.app.render_workspace.view.dirty = true;
h.frames(3);
let doc = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
- h.step(&json!({"widget":check})).unwrap();
- h.step(&json!({"widget":start})).unwrap();
+ click_render_check(&mut h);
+ h.step(&json!({"click":{"handle":"render:stage:render.start"}})).unwrap();
for _ in 0..50 {
h.frames(1);
if h.app.render_workspace.view.completed.is_some() {
@@ -1305,7 +1314,7 @@ fn clicked_image_controls_complete_cancel_and_export_without_dirtying_the_design
assert!(h.dir.join("render.png").is_file());
h.app.render_workspace.view.draft.width = 1024;
h.app.render_workspace.view.draft.height = 768;
- h.step(&json!({"widget":start})).unwrap();
+ h.step(&json!({"click":{"handle":"render:stage:render.start"}})).unwrap();
assert!(job_ready(&h.app, "render.cancel").is_ok());
h.step(&json!({"click":{"handle":"render:stage:render.cancel"}})).unwrap();
h.frames(5);
@@ -1330,13 +1339,19 @@ fn saved_camera_survives_frames_and_product_fit_ignores_selection() {
h.frames(3);
let design = h.app.cam;
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
+ h.frames(3);
+ h.app.run("view.render_select", json!({"kind":"shot","id":"Studio"})).unwrap();
h.frames(3);
- h.step(&json!({"widget":"Restore Saved Camera"})).unwrap();
+ h.step(&json!({"click":{"handle":"render:shot:revert"}})).unwrap();
h.frames(3);
assert_eq!(h.app.cam, camera);
assert_eq!(h.app.render_workspace.view.draft.background, [21, 43, 65]);
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Product".into() }];
+ {
+ let selection = object_selection(&h.app);
+ selection_editor(&mut h.app, &selection);
+ }
h.call("engine.execute", json!({"command":"view.fit","params":{}}));
h.frames(3);
let selected_fit = h.app.cam;
@@ -1516,7 +1531,7 @@ fn progressive_image_controls_route_to_the_registered_host() {
h.app.session.mark_saved();
h.call("ui.resize", json!({"width":1600,"height":1600}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.render_workspace.view.draft.width = 16;
h.app.render_workspace.view.draft.height = 16;
h.app.render_workspace.view.samples = 4;
@@ -1528,6 +1543,16 @@ fn progressive_image_controls_route_to_the_registered_host() {
h.app.render_workspace.view.studio.lens.aperture_radius_mm = 0.0;
h.app.render_workspace.view.studio.lighting_enabled = true;
h.app.render_workspace.view.studio.ambient = [0.75; 3];
+ h.frames(3);
+ let engineering = h.app.session.doc.features.clone();
+ h.step(&json!({"click":{"handle":"render:method"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:method-gpu"}})).unwrap();
+ assert_eq!(h.app.render_workspace.view.method, ImageMethod::GpuRaytrace);
+ assert_eq!(h.app.session.doc.features, engineering);
+ assert!(matches!(
+ h.app.session.doc.render.setups[&h.app.render_workspace.view.name].job,
+ Some(solidcraft_engine::doc::render_settings::RenderJob::GpuPath { .. })
+ ));
// The UI request reaches the real registered host with a coat and captured map.
let target: materials::Target = serde_json::from_value(h.app.run("render.scene", json!({})).unwrap()["bodies"][0].clone()).unwrap();
let mut material = materials::Binding::new(target, &h.app);
@@ -1538,19 +1563,16 @@ fn progressive_image_controls_route_to_the_registered_host() {
material.maps.color = map_path.to_string_lossy().into_owned();
h.app.render_workspace.view.materials.enabled = true;
h.app.render_workspace.view.materials.bindings.push(material);
- h.frames(3);
+ h.app.session.mark_saved();
let doc = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
- h.step(&json!({"click":{"handle":"render:method"}})).unwrap();
- h.step(&json!({"click":{"handle":"render:method-gpu"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.method, ImageMethod::GpuRaytrace);
let checked = image_params(&h.app).unwrap();
assert_eq!(checked["raytrace"]["clear_coats"][0]["weight"], 1.0);
assert_eq!(checked["raytrace"]["textures"][0]["base_color_srgb"], map_path.to_string_lossy().as_ref());
h.app.run("render.preflight", checked.clone()).unwrap();
assert_eq!(image_params(&h.app).unwrap(), checked);
- let start = h.app.tr("render.image_start").to_string();
- h.step(&json!({"widget":start})).unwrap();
+
+ h.step(&json!({"click":{"handle":"render:stage:render.start"}})).unwrap();
let job = h.app.render_workspace.view.job.unwrap();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
while h.app.render_workspace.view.completed.is_none() {
@@ -1568,7 +1590,7 @@ fn progressive_image_controls_route_to_the_registered_host() {
assert_eq!(status["options"]["lens"]["aperture_radius_mm"], 0.0);
assert_eq!(status["options"]["lighting"]["environment"], json!([0.75, 0.75, 0.75]));
assert_eq!(status["textures"]["bodies"], 1);
- let export = h.app.tr("render.image_export").to_string();
+ let export = studio::export_label(&h.app).to_string();
h.step(&json!({"widget":export})).unwrap();
assert!(h.dir.join("render.png").is_file());
assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
@@ -1594,11 +1616,10 @@ fn progressive_image_controls_route_to_the_registered_host() {
}
#[test]
-fn clicked_render_workspace_saves_one_setup_and_restores_design_view() {
+fn clicked_shot_editor_saves_camera_and_restores_design_view() {
for language in ["en", "de", "ko", "ru"] {
let mut h = Harness::new();
h.app.preferences.language = language.into();
- h.app.preferences.perspective_fov = 50f64.to_radians();
h.app.run("solid.box", json!({"length":10,"width":20,"height":5})).unwrap();
h.app.session.mark_saved();
h.frames(3);
@@ -1609,24 +1630,27 @@ fn clicked_render_workspace_saves_one_setup_and_restores_design_view() {
h.step(&json!({"click":[at.x,at.y]})).unwrap();
h.step(&json!({"click":{"handle":"menu:ui.workspace.render"}})).unwrap();
assert!(active(&h.app));
- let heading = h.app.tr("render.page_scene").to_string();
- let perspective = h.app.tr("render.perspective").to_string();
- let save = h.app.tr("render.save_setup").to_string();
- let back = h.app.tr("render.return_design").to_string();
- assert!(h.widget(&heading).is_some(), "{language}");
- h.step(&json!({"click":{"handle":"render:scene:frame"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Camera);
- h.step(&json!({"widget":perspective})).unwrap();
- assert_eq!(h.app.cam.fov, 50f64.to_radians(), "{language}: Perspective takes the Field of view preference's angle (#5364)");
- assert!(!h.app.session.is_dirty(), "preview edits are staged");
- h.step(&json!({"widget":save})).unwrap();
- assert_eq!(h.app.session.undo.len(), undo + 1);
+ assert!(h.widget(h.app.tr("render.page_scene")).is_some(), "{language}");
+ h.step(&json!({"click":{"handle":"render:shots:save"}})).unwrap();
+ h.app.render_workspace.view.save_shot_name = Some("Studio".into());
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"shot","id":"Studio"})).unwrap();
+ h.frames(3);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Camera);
+ h.step(&json!({"widget":h.app.tr("render.perspective")})).unwrap();
+ assert_eq!(h.app.cam.fov, 35f64.to_radians(), "{language}: keep the current Shot editor's projection behavior");
+ assert_eq!(h.app.session.undo.len(), undo + 2);
assert_eq!(h.app.session.doc.render.setups["Studio"].camera, h.app.cam);
- h.step(&json!({"widget":back})).unwrap();
+ let at = crate::scenario::rect_of("workspace_switcher").unwrap().center();
+ h.step(&json!({"click":[at.x,at.y]})).unwrap();
+ h.step(&json!({"click":{"handle":"menu:ui.workspace.design"}})).unwrap();
assert!(!active(&h.app));
assert_eq!(h.app.cam, camera);
assert_eq!(flags, (h.app.ui.show_grid, h.app.origin_shown(), h.app.ui.visual_style, h.app.ui.perspective));
- h.app.run("edit.undo", json!({})).unwrap();
+ for _ in 0..2 {
+ h.app.run("edit.undo", json!({})).unwrap();
+ }
assert!(!h.app.session.is_dirty());
}
}
@@ -1641,7 +1665,7 @@ fn render_drafts_and_capabilities_are_isolated_across_document_switches() {
h.app.render_workspace.view.draft.background = [20, 40, 60];
h.app.render_workspace.view.dirty = true;
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
crate::documents::open_tab(&mut h.app, Session::default()).unwrap();
assert!(!active(&h.app));
assert_eq!(h.app.render_workspace.view.name, "Studio");
@@ -1991,7 +2015,7 @@ fn result_canvas_paints_large_capture_reports_staleness_and_preserves_export() {
h.app.render_workspace.view.completed = Some(job);
h.app.render_workspace.view.result = true;
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
let preview = h.app.cam;
let doc = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
@@ -2043,7 +2067,7 @@ fn result_navigation_uses_shared_pan_zoom_and_leaves_product_camera_unchanged()
h.app.render_workspace.view.completed = Some(job);
h.app.render_workspace.view.result = true;
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.ui.perspective = true;
h.app.preferences.smooth_wheel_zoom = false;
h.app.preferences.zoom_reverse = false;
@@ -2123,22 +2147,22 @@ fn clicked_result_controls_switch_canvas_and_frame_without_changing_the_setup()
let job = completed_preview(&mut h, [20, 40, 60]);
h.app.render_workspace.view.job = Some(job);
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
let camera = h.app.cam;
let doc = h.app.session.doc.clone();
- let result = h.app.tr("render.result_title").to_string();
+ let result = h.app.tr("render.output_view_image").to_string();
h.step(&json!({"widget":result})).unwrap();
h.frames(2);
assert!(h.app.render_workspace.view.result);
- h.step(&json!({"widget":"100%"})).unwrap();
+ h.step(&json!({"widget":h.app.tr("render.result_actual")})).unwrap();
h.frames(2);
assert_eq!(h.app.render_workspace.view.result_scale, ResultScale::Actual);
- let fit = h.app.tr("render.result_fit").to_string();
+ let fit = h.app.tr("render.output_fit").to_string();
h.step(&json!({"widget":fit})).unwrap();
h.frames(2);
assert_eq!(h.app.render_workspace.view.result_scale, ResultScale::Fit);
- let preview = h.app.tr("render.result_preview").to_string();
+ let preview = h.app.tr("render.state_model").to_string();
h.step(&json!({"widget":preview})).unwrap();
assert!(!h.app.render_workspace.view.result);
assert_eq!(h.app.cam, camera);
@@ -2149,7 +2173,7 @@ fn clicked_result_controls_switch_canvas_and_frame_without_changing_the_setup()
fn image_method_requests_never_fall_back_or_mix_cpu_and_gpu_options() {
let mut h = Harness::new();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.render_workspace.view.result = true;
h.app.render_workspace.view.result_camera.distance = h.app.cam.distance * 3.0;
h.app.render_workspace.view.raytrace.exposure_ev = f64::NAN;
@@ -2191,10 +2215,10 @@ fn native_cpu_controls_check_and_start_the_same_capture_and_keep_it_exportable()
h.app.run("solid.box", json!({"length":10,"width":20,"height":5})).unwrap();
h.call("ui.resize", json!({"width":1600,"height":1800}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
- h.app.render_workspace.view.draft.width = 16;
- h.app.render_workspace.view.draft.height = 16;
- h.app.render_workspace.view.dirty = true;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
+ // Keep the small capture size in the saved setup across editor autosaves.
+ let name = h.app.render_workspace.view.name.clone();
+ h.app.run("render.settings.set", json!({"name":name,"set":{"width":16,"height":16}})).unwrap();
h.frames(3);
let available = image_host(&h.app, ImageMethod::CpuRaytrace).is_ok();
h.step(&json!({"click":{"handle":"render:method"}})).unwrap();
@@ -2205,6 +2229,9 @@ fn native_cpu_controls_check_and_start_the_same_capture_and_keep_it_exportable()
return;
}
assert_eq!(h.app.render_workspace.view.method, ImageMethod::CpuRaytrace);
+ h.app.run("view.render_select", json!({"kind":"sampling"})).unwrap();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.children.cpu"))}})).unwrap();
h.step(&json!({"click":{"handle":"render:aa"}})).unwrap();
h.step(&json!({"click":{"handle":"render:aa-4"}})).unwrap();
assert_eq!(h.app.render_workspace.view.raytrace.primary_samples, 4);
@@ -2213,22 +2240,20 @@ fn native_cpu_controls_check_and_start_the_same_capture_and_keep_it_exportable()
let numeric = image_params(&h.app).unwrap();
assert_eq!(numeric["settings"]["job"]["method"], "cpu_raytrace");
assert!(numeric.get("raytrace").is_none());
- let numeric_check = h.app.tr("cmd.render_preflight").to_string();
- h.step(&json!({"widget":numeric_check})).unwrap();
+
+ click_render_check(&mut h);
assert_eq!(h.app.render_workspace.view.cpu.checked.as_ref().unwrap().request, numeric);
let reflected = h.app.session.world_state().bodies.first().unwrap().name.clone();
- let reflection_section = format!("dialog:section:{}", h.app.tr("render.cpu_reflections"));
- h.step(&json!({"click":{"handle":reflection_section}})).unwrap();
- h.step(&json!({"click":{"handle":"render:cpu-reflection-body"}})).unwrap();
- h.step(&json!({"click":{"handle":format!("dialog:list:{reflected}")}})).unwrap();
- h.step(&json!({"click":{"handle":"render:cpu-reflection-add"}})).unwrap();
- h.step(&json!({"click":{"handle":format!("render:cpu-reflection-mode:{reflected}")}})).unwrap();
- h.step(&json!({"click":{"handle":"dialog:list:render.cpu_reflection_mirror"}})).unwrap();
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: reflected }]})).unwrap();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.appearance_editor.reflections"))}})).unwrap();
+ h.step(&json!({"widget":h.app.tr("render.cpu_reflection_mirror")})).unwrap();
assert_eq!(
h.app.render_workspace.view.raytrace.reflections.as_ref().unwrap().bodies[0].mode,
solidcraft_engine::render::job::ReflectionMode::Mirror
);
- h.step(&json!({"click":{"handle":reflection_section}})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"output"})).unwrap();
+ h.frames(3);
let hdr_path = h.dir.join("cpu-captured.hdr");
let mut hdr = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 1 +X 2\n".to_vec();
hdr.extend_from_slice(&[128, 128, 128, 129, 128, 128, 128, 129]);
@@ -2245,14 +2270,14 @@ fn native_cpu_controls_check_and_start_the_same_capture_and_keep_it_exportable()
let params = image_params(&h.app).unwrap();
let preflight = h.app.session.execute("render.preflight", &params).unwrap();
assert_eq!(preflight["resolved"]["executor"], "cpu-raytrace");
- let check = h.app.tr("cmd.render_preflight").to_string();
- h.step(&json!({"widget":check})).unwrap();
+
+ click_render_check(&mut h);
assert_eq!(image_params(&h.app).unwrap(), params);
let checked = h.app.render_workspace.view.cpu.checked.as_ref().unwrap();
assert_eq!(checked.request, params);
assert_eq!(checked.environment, preflight["environment"]);
- let start = h.app.tr("render.image_start").to_string();
- h.step(&json!({"widget":start})).unwrap();
+
+ h.step(&json!({"click":{"handle":"render:stage:render.start"}})).unwrap();
let id = h.app.render_workspace.view.job.unwrap();
let handle = h.app.session.render_job_handle(id).unwrap();
// The job owns the source bytes captured by Start, even if the file changes.
@@ -2545,7 +2570,7 @@ fn render_workspace_view_keys_double_middle_click_and_navigators_work() {
h.app.preferences.look_at_anim = false;
h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Product"})).unwrap();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.frames(3);
let mut home = h.app.cam;
home.set_view(solidcraft_engine::render::StandardView::Iso);
@@ -2736,6 +2761,107 @@ fn gpu_material_recipes_use_exact_linear_absorption_without_changing_saved_appea
assert!(raster.get("raytrace").is_none());
}
+#[test]
+fn numeric_editor_save_refreshes_only_unchanged_runtime_binding_sources() {
+ use solidcraft_engine::render::job::ReflectionMode;
+ for (method, change_geometry) in
+ [(ImageMethod::GpuRaytrace, false), (ImageMethod::GpuRaytrace, true), (ImageMethod::CpuRaytrace, false), (ImageMethod::CpuRaytrace, true)]
+ {
+ let mut h = Harness::new();
+ h.app.run("solid.box", json!({"length":10,"width":10,"height":3,"body_name":"Target"})).unwrap();
+ enter(&mut h.app, true).unwrap();
+ select_image_method(&mut h.app, method);
+ setups::save(&mut h.app).unwrap();
+ if method == ImageMethod::GpuRaytrace {
+ let target = materials::read_targets(&mut h.app).unwrap().remove(0);
+ let mut binding = materials::Binding::new(target, &h.app);
+ binding.maps_enabled = true;
+ binding.maps.color = "unchanged-source.png".into();
+ h.app.render_workspace.view.materials.enabled = true;
+ h.app.render_workspace.view.materials.bindings.push(binding);
+ } else {
+ cpu::set_reflection(&mut h.app, "Target", Some(ReflectionMode::Mirror)).unwrap();
+ }
+ let runtime = image_request(&h.app).unwrap();
+ let features = h.app.session.doc.features.clone();
+ let undo = h.app.session.undo.len();
+ let before = setups::draft(&h.app).unwrap();
+ if method == ImageMethod::GpuRaytrace {
+ h.app.render_workspace.view.samples += 1;
+ } else {
+ h.app.render_workspace.view.raytrace.primary_samples = 4;
+ }
+ setups::persist_editor(&mut h.app, &before).unwrap();
+ let after = image_request(&h.app).expect("render-only persistence must retain current bindings");
+ assert_eq!(after["raytrace"]["textures"], runtime["raytrace"]["textures"]);
+ if method == ImageMethod::GpuRaytrace {
+ assert_eq!(after["raytrace"]["textures"][0]["base_color_srgb"], "unchanged-source.png");
+ } else {
+ assert!(after["raytrace"]["reflections"]["bodies"].as_array().is_some_and(|bodies| bodies.len() == 1));
+ }
+ assert_eq!(after["raytrace"]["reflections"], runtime["raytrace"]["reflections"]);
+ assert_eq!(h.app.session.doc.features, features);
+ assert_eq!(h.app.session.undo.len(), undo + 1);
+ if change_geometry {
+ h.app.run("solid.box", json!({"length":2,"width":2,"height":2,"corner":[20,0,0],"body_name":"Later","operation":"new"})).unwrap();
+ } else {
+ h.app.run("appearance.assign", json!({"bodies":["Target"],"color":"#123456"})).unwrap();
+ }
+ assert!(image_request(&h.app).is_err());
+ let before = setups::draft(&h.app).unwrap();
+ h.app.render_workspace.view.draft.exposure_ev += 0.25;
+ setups::persist_editor(&mut h.app, &before).unwrap();
+ assert!(image_request(&h.app).is_err(), "a render save must never bless a changed material source");
+ h.app.run("browser.visibility", json!({"items":["Target"],"visible":false})).unwrap();
+ let before = setups::draft(&h.app).unwrap();
+ h.app.render_workspace.view.draft.exposure_ev += 0.25;
+ setups::persist_editor(&mut h.app, &before).unwrap();
+ assert!(image_request(&h.app).is_err(), "hidden or moved targets must remain stale");
+ }
+}
+
+#[test]
+fn undo_numeric_editor_sync_preserves_runtime_inputs_and_camera_draft() {
+ use solidcraft_engine::render::job::ReflectionMode;
+ let mut h = Harness::new();
+ h.call("ui.resize", json!({"width":1600,"height":2600}));
+ h.app.run("solid.box", json!({"length":10,"width":10,"height":3,"body_name":"Target"})).unwrap();
+ enter(&mut h.app, true).unwrap();
+ select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
+ h.app.render_workspace.view.raytrace.primary_samples = 1;
+ setups::save(&mut h.app).unwrap();
+ h.app.run("view.render_select", json!({"kind":"sampling"})).unwrap();
+ cpu::set_reflection(&mut h.app, "Target", Some(ReflectionMode::Mirror)).unwrap();
+ h.app.cancel_view_animation();
+ h.app.cam.yaw += 0.25;
+ let camera = h.app.cam;
+ let saved = h.app.session.doc.render.setups["Studio"].clone();
+ let request = image_request(&h.app).unwrap();
+ let undo = h.app.session.undo.len();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.children.cpu"))}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:aa"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:aa-4"}})).unwrap();
+ assert_eq!(h.app.render_workspace.view.raytrace.primary_samples, 4);
+ assert_eq!(h.app.session.undo.len(), undo + 1);
+ h.frames(3);
+ h.app.run("edit.undo", json!({})).unwrap();
+ h.frames(3);
+ assert_eq!(h.app.session.doc.render.setups["Studio"], saved);
+ assert_eq!(h.app.render_workspace.view.raytrace.primary_samples, 1, "Undo must reach the actual Sampling editor");
+ assert!(h.widget("1×").is_some(), "the visible Sampling control must show the undone value");
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(image_request(&h.app).unwrap(), request, "Undo must preserve valid temporary reflection bindings");
+ assert_eq!(h.app.session.undo.len(), undo);
+ assert!(h.app.render_workspace.view.dirty, "the camera and reflection drafts remain unsaved");
+ h.app.run("edit.redo", json!({})).unwrap();
+ h.frames(3);
+ assert_eq!(h.app.render_workspace.view.raytrace.primary_samples, 4);
+ assert!(h.widget("4×").is_some());
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(image_request(&h.app).unwrap()["raytrace"]["reflections"], request["raytrace"]["reflections"]);
+}
+
#[test]
fn gpu_material_identity_requires_explicit_revalidation_and_never_retargets() {
let mut h = Harness::new();
@@ -2780,19 +2906,12 @@ fn clicked_gpu_glass_recipe_stays_temporary_and_blocks_cpu_rendering() {
h.app.run("solid.box", json!({"length":10,"width":10,"height":3,"body_name":"Optics"})).unwrap();
h.app.session.mark_saved();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.render_workspace.view.method = ImageMethod::GpuRaytrace;
h.frames(3);
let doc = h.app.session.doc.clone();
- let title = h.app.tr("render.material_title").to_string();
- h.step(&json!({"click":{"handle":format!("dialog:section:{title}")}})).unwrap();
- let refresh = h.app.tr("render.material_refresh").to_string();
- h.step(&json!({"widget":refresh})).unwrap();
- let choose = h.app.tr("render.material_choose_body").to_string();
- h.step(&json!({"widget":choose})).unwrap();
- h.step(&json!({"click":{"handle":"dialog:list:render:material-body-0"}})).unwrap();
- let add = h.app.tr("render.material_add").to_string();
- h.step(&json!({"widget":add})).unwrap();
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: "Optics".into() }]})).unwrap();
+ h.frames(3);
let glass = h.app.tr("render.appearance_editor.glass").to_string();
h.step(&json!({"click":{"handle":format!("dialog:section:{glass}")}})).unwrap();
h.step(&json!({"widget":h.app.tr("render.material_custom")})).unwrap();
@@ -2819,29 +2938,22 @@ fn clicked_gpu_material_at_assignment_limit_edits_existing_but_cannot_add_anothe
let doc = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.render_workspace.view.materials.bindings = targets.iter().skip(1).cloned().map(|target| materials::Binding::new(target, &h.app)).collect();
+ h.app.render_workspace.view.method = ImageMethod::GpuRaytrace;
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: targets[1].name.clone() }]})).unwrap();
h.frames(3);
- let title = h.app.tr("render.material_title").to_string();
- h.step(&json!({"click":{"handle":format!("dialog:section:{title}")}})).unwrap();
- let refresh = h.app.tr("render.material_refresh").to_string();
- h.step(&json!({"widget":refresh})).unwrap();
- let choose = h.app.tr("render.material_choose_body").to_string();
- h.step(&json!({"widget":choose})).unwrap();
- h.step(&json!({"click":{"handle":format!("dialog:list:render:material-body-{}", targets[1].ordinal)}})).unwrap();
- let add = h.app.tr("render.material_add").to_string();
- h.step(&json!({"widget":add})).unwrap();
- let include = h.app.tr("render.material_binding_enable").to_string();
- h.step(&json!({"widget":include})).unwrap();
- assert!(!h.app.render_workspace.view.materials.bindings[0].enabled, "the existing assignment remains editable at the limit");
- assert!(h.app.render_workspace.view.materials.bindings.iter().skip(1).all(|binding| binding.enabled));
+ let glass = h.app.tr("render.appearance_editor.glass").to_string();
+ h.step(&json!({"click":{"handle":format!("dialog:section:{glass}")}})).unwrap();
+ h.step(&json!({"widget":h.app.tr("render.appearance_editor.glass_enable")})).unwrap();
+ assert!(h.app.render_workspace.view.materials.bindings[0].glass_enabled, "existing assignments remain editable at the limit");
+ assert!(h.app.render_workspace.view.materials.bindings.iter().skip(1).all(|binding| !binding.glass_enabled));
assert_eq!(h.app.render_workspace.view.materials.bindings.len(), 128);
- // The first scene body has no assignment: selecting it cannot create a 129th entry.
- h.step(&json!({"widget":refresh})).unwrap();
- h.step(&json!({"widget":choose})).unwrap();
- h.step(&json!({"click":{"handle":format!("dialog:list:render:material-body-{}", targets[0].ordinal)}})).unwrap();
- h.step(&json!({"widget":add})).unwrap();
+ // The first body has no assignment: editing cannot allocate a 129th entry.
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name: targets[0].name.clone() }]})).unwrap();
+ h.frames(3);
+ h.step(&json!({"widget":h.app.tr("render.appearance_editor.glass_enable")})).unwrap();
assert_eq!(h.app.render_workspace.view.materials.bindings.len(), 128);
assert!(h.app.render_workspace.view.materials.bindings.iter().all(|binding| binding.target != targets[0]));
assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
@@ -3109,32 +3221,28 @@ fn clicked_setup_save_reload_and_switch_keep_gpu_numeric_intent_without_a_host()
assert!(!h.app.render_workspace.view.dirty);
assert!(image_params(&h.app).is_err(), "offline editing must not claim an executable GPU");
assert_eq!(image_request(&h.app).unwrap(), json!({"settings":expected}));
- h.step(&json!({"click":{"handle":"render:setup-name"}})).unwrap();
- h.step(&json!({"key":"A","cmd":true})).unwrap();
- h.step(&json!({"text":"GPU copy"})).unwrap();
+ h.app.render_workspace.view.name = "GPU copy".into();
+ h.app.render_workspace.view.dirty = true;
assert_eq!(h.app.render_workspace.view.name, "GPU copy");
assert_eq!(setups::snapshot(&h.app).unwrap(), expected, "typing Save As must not reset the settings");
assert!(h.app.render_workspace.view.dirty);
let undo = h.app.session.undo.len();
- h.step(&json!({"widget":h.app.tr("render.save_setup")})).unwrap();
+ setups::save(&mut h.app).unwrap();
assert_eq!(h.app.session.undo.len(), undo + 1);
assert_eq!(h.app.session.doc.render.setups["GPU copy"], expected);
h.app.render_workspace.view.seed = 8;
h.app.render_workspace.view.studio.ambient[1] = 0.125;
setups::refresh_dirty(&mut h.app);
assert!(h.app.render_workspace.view.dirty);
- h.step(&json!({"widget":h.app.tr("render.reload_settings")})).unwrap();
- if h.app.render_workspace.view.dirty {
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
- }
+ setups::load(&mut h.app);
+ h.frames(3);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
assert!(!h.app.render_workspace.view.dirty);
select_image_method(&mut h.app, ImageMethod::Raster);
h.app.render_workspace.view.name = "Raster saved".into();
setups::save(&mut h.app).unwrap();
h.frames(3);
- h.step(&json!({"click":{"handle":"render:setups"}})).unwrap();
- h.step(&json!({"click":{"handle":"render:setup:GPU copy"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:shots:setup:GPU copy"}})).unwrap();
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
assert_eq!(h.app.render_workspace.view.completed, completed);
assert_eq!(h.app.render_workspace.view.result_camera, result_camera);
@@ -3151,7 +3259,7 @@ fn cpu_setup_reload_preserves_unedited_numeric_options_and_explicit_empty_values
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2400}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
let options: CpuJob = serde_json::from_value(json!({
"primary_samples":4,"shadows":false,
"lights":[{"direction":[2.0,-4.0,8.0],"color":[0.2,0.4,0.6],"intensity":3.0}],
@@ -3198,13 +3306,15 @@ fn cpu_progressive_controls_resize_only_on_request_and_save_reload_without_a_hos
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2600}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Sampling);
h.app.session.set_render_job_host(None).unwrap();
select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
h.app.render_workspace.view.raytrace.primary_samples = 16;
h.app.render_workspace.view.draft.width = 1024;
h.app.render_workspace.view.draft.height = 1024;
h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.children.cpu"))}})).unwrap();
+ h.frames(3);
h.step(&json!({"click":{"handle":"render:cpu-sampling"}})).unwrap();
h.step(&json!({"click":{"handle":"render:cpu-progressive"}})).unwrap();
assert_eq!(h.app.render_workspace.view.raytrace.primary_samples, 1);
@@ -3221,23 +3331,27 @@ fn cpu_progressive_controls_resize_only_on_request_and_save_reload_without_a_hos
assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), (1024, 1024));
assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
assert_eq!(h.app.session.undo.len(), undo);
- let resize = format!("{} 512 × 512", h.app.tr("render.image_use_largest"));
+ h.app.run("view.render_select", json!({"kind":"output"})).unwrap();
+ h.frames(3);
+ let resize = crate::i18n::format("render.output_largest", &[("width", "512"), ("height", "512")]);
assert!(h.widget(&resize).is_some(), "the proposed dimensions must be visible before accepting them");
h.step(&json!({"widget":resize})).unwrap();
assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), (512, 512));
let expected = setups::snapshot(&h.app).unwrap();
assert_eq!(image_request(&h.app).unwrap(), json!({"settings":expected}));
assert!(image_request(&h.app).unwrap().get("progressive").is_none(), "CPU sampling must not select the GPU executor");
- h.step(&json!({"widget":h.app.tr("render.save_setup")})).unwrap();
+ setups::save(&mut h.app).unwrap();
assert_eq!(h.app.session.doc.render.setups["Progressive CPU"], expected);
+ h.app.run("view.render_select", json!({"kind":"sampling"})).unwrap();
+ h.frames(3);
h.step(&json!({"click":{"handle":"render:cpu-sampling"}})).unwrap();
h.step(&json!({"click":{"handle":"render:cpu-fixed"}})).unwrap();
assert!(h.app.render_workspace.view.raytrace.progressive.is_none());
- assert!(h.app.render_workspace.view.dirty);
- h.step(&json!({"widget":h.app.tr("render.reload_settings")})).unwrap();
- if h.app.render_workspace.view.dirty {
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
- }
+ assert!(!h.app.render_workspace.view.dirty, "Sampling saves its numerical edit immediately");
+ h.app.run("edit.undo", json!({})).unwrap();
+ h.frames(3);
+ assert_eq!(h.app.session.doc.render.setups["Progressive CPU"], expected);
+ assert!(h.app.render_workspace.view.raytrace.progressive.is_some());
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
assert!(!h.app.render_workspace.view.dirty);
h.app.render_workspace.view.name = "Progressive CPU copy".into();
@@ -3293,7 +3407,7 @@ fn setup_save_refuses_nonportable_state_atomically_and_tracks_invalid_legacy_edi
let mut h = Harness::new();
h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Target"})).unwrap();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
setups::load(&mut h.app);
select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
setups::save(&mut h.app).unwrap();
@@ -3365,13 +3479,12 @@ fn hdr_ui_save_embeds_once_without_a_host_and_reload_never_reopens_the_source_pa
h.app.run("solid.box", json!({"body_name":"HDR target","length":10,"width":20,"height":5})).unwrap();
h.call("ui.resize", json!({"width":1600,"height":2200}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
h.app.session.set_render_job_host(None).unwrap();
let path = h.dir.join("original-embedded.hdr");
let bytes = original_hdr_bytes(128, true);
std::fs::write(&path, &bytes).unwrap();
let resource = solidcraft_engine::doc::render_resources::HdrId::of(&bytes);
- let save = h.app.tr("render.save_setup").to_string();
select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
h.app.render_workspace.view.name = "HDR GPU".into();
h.app.render_workspace.view.draft.width = 16;
@@ -3387,7 +3500,7 @@ fn hdr_ui_save_embeds_once_without_a_host_and_reload_never_reopens_the_source_pa
let unsaved = image_request(&h.app).unwrap();
assert_eq!(unsaved["environment"]["expected_sha256"], json!(resource));
h.frames(3);
- h.step(&json!({"widget":save})).unwrap();
+ setups::save(&mut h.app).unwrap();
assert_eq!(h.app.session.undo.len(), before.1 + 1);
assert_eq!(h.app.render_workspace.view.studio.hdr, hdr::Input::EmbeddedResource { resource });
assert_eq!(h.app.session.doc.render.resources.len(), 1);
@@ -3407,7 +3520,7 @@ fn hdr_ui_save_embeds_once_without_a_host_and_reload_never_reopens_the_source_pa
hdr::inspect(&mut h.app, hdr::Target::Cpu, path.to_string_lossy().into_owned()).unwrap();
let undo = h.app.session.undo.len();
h.frames(2);
- h.step(&json!({"widget":save})).unwrap();
+ setups::save(&mut h.app).unwrap();
assert_eq!(h.app.session.undo.len(), undo + 1);
assert_eq!(h.app.session.doc.render.resources.len(), 1, "both setups share one source payload");
assert_eq!(h.app.session.doc.render.resources.total_bytes(), bytes.len());
@@ -3429,12 +3542,9 @@ fn hdr_ui_save_embeds_once_without_a_host_and_reload_never_reopens_the_source_pa
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
assert_eq!(image_request(&h.app).unwrap(), json!({"settings":expected}));
let before = (h.app.session.revision, h.app.session.undo.len());
- let section = if target == hdr::Target::Cpu { "render.cpu_environment" } else { "render.studio_environment" };
- h.frames(2);
- if target == hdr::Target::Gpu {
- h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.image_advanced"))}})).unwrap();
- }
- h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr(section))}})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"environment"})).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:environment:intensity").is_some());
h.frames(2);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected, "displaying degrees must preserve saved radians");
setups::save(&mut h.app).unwrap();
@@ -3447,7 +3557,7 @@ fn hdr_ui_save_embeds_once_without_a_host_and_reload_never_reopens_the_source_pa
fn changed_hdr_bytes_reject_save_atomically_and_check_start_keep_the_expected_digest() {
let mut h = Harness::new();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
h.app.render_workspace.view.name = "Pinned HDR".into();
h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr;
@@ -3518,7 +3628,7 @@ fn embedded_hdr_runtime_requests_preserve_temporary_bindings_without_serializing
let mut h = Harness::new();
h.app.run("solid.box", json!({"body_name":"Target","length":10,"width":20,"height":5})).unwrap();
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Output);
select_image_method(&mut h.app, if target == hdr::Target::Cpu { ImageMethod::CpuRaytrace } else { ImageMethod::GpuRaytrace });
h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr;
h.app.render_workspace.view.studio.environment = studio::Environment::Hdr;
@@ -3563,7 +3673,7 @@ fn cpu_resource_profile_edits_preserve_resolution_samples_and_saved_intent() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2600}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Sampling);
h.app.session.set_render_job_host(None).unwrap();
select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
h.app.render_workspace.view.name = "Studio output".into();
@@ -3572,17 +3682,23 @@ fn cpu_resource_profile_edits_preserve_resolution_samples_and_saved_intent() {
h.app.render_workspace.view.raytrace.budget = CpuBudget::Studio;
h.app.render_workspace.view.raytrace.progressive = Some(CpuProgressiveOptions { samples_per_pixel: 128, seed: 82 });
h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.children.cpu"))}})).unwrap();
+ h.frames(3);
let expected = setups::snapshot(&h.app).unwrap();
setups::save(&mut h.app).unwrap();
setups::load(&mut h.app);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
+ let saved = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
h.step(&json!({"click":{"handle":"render.cpu_budget_compact"}})).unwrap();
h.frames(3);
assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), (3840, 2160));
assert_eq!(h.app.render_workspace.view.raytrace.progressive.unwrap().samples_per_pixel, 128);
- assert!(setups::snapshot(&h.app).is_err());
- assert!(h.app.render_workspace.view.dirty);
+ assert_eq!(h.app.render_workspace.view.raytrace.budget, CpuBudget::Studio, "an invalid saved edit is refused without resizing");
+ assert_eq!(h.app.session.doc, saved);
+ assert_eq!(h.app.session.undo.len(), undo);
+ assert!(h.app.status.is_some(), "the refused budget needs its reason");
setups::load(&mut h.app);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
}
@@ -3619,46 +3735,50 @@ fn large_image_display_uses_captured_profile_and_keeps_export_pixels_unchanged()
}
#[test]
-fn setup_actions_and_return_design_stay_visible_with_long_render_controls() {
+fn stage_actions_and_workspace_return_stay_visible_with_long_render_controls() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1280,"height":900}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Sampling);
select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
h.frames(3);
- for key in ["render.save_setup", "render.reload_settings", "render.return_design"] {
- let label = h.app.tr(key).to_string();
- assert!(h.widget(&label).is_some(), "sticky action {key}");
+ let bar = crate::scenario::rect_of("render:stage_bar").unwrap();
+ for id in ["render:stage:render.start", "render:stage:render.cancel"] {
+ assert!(bar.contains_rect(crate::scenario::rect_of(id).unwrap()));
}
- h.step(&json!({"widget":h.app.tr("render.return_design")})).unwrap();
+ for key in ["render.save_setup", "render.reload_settings"] {
+ assert!(h.widget(h.app.tr(key)).is_none(), "removed studio action {key}");
+ }
+ let at = crate::scenario::rect_of("workspace_switcher").unwrap().center();
+ h.step(&json!({"click":[at.x,at.y]})).unwrap();
+ h.step(&json!({"click":{"handle":"menu:ui.workspace.design"}})).unwrap();
assert!(!active(&h.app));
}
#[test]
-fn dirty_indication_preserves_reload_and_resource_picker_hit_targets() {
+fn camera_draft_preserves_sampling_resource_picker_hit_targets() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2600}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ inspector::select_editor(&mut h.app, inspector::Editor::Sampling);
select_image_method(&mut h.app, ImageMethod::CpuRaytrace);
setups::save(&mut h.app).unwrap();
setups::load(&mut h.app);
+ let saved = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.children.cpu"))}})).unwrap();
h.frames(3);
- let reload = h.app.tr("render.reload_settings").to_string();
- let clean_reload = h.widget(&reload).unwrap();
let clean_picker = crate::scenario::rect_of("render:cpu-budget").unwrap();
- h.app.render_workspace.view.draft.exposure_ev = 1.0;
+ h.app.cam.yaw += 0.25;
setups::refresh_dirty(&mut h.app);
assert!(h.app.render_workspace.view.dirty);
h.frames(3);
- assert_eq!(h.widget(&reload).unwrap(), clean_reload, "dirty text must not move Reload");
- assert_eq!(crate::scenario::rect_of("render:cpu-budget").unwrap(), clean_picker, "dirty text must not move the CPU resource picker");
- h.step(&json!({"widget":reload})).unwrap();
- if h.app.render_workspace.view.dirty {
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
- }
- assert!(!h.app.render_workspace.view.dirty);
- assert_eq!(h.app.render_workspace.view.draft.exposure_ev, 0.0);
+ assert_eq!(crate::scenario::rect_of("render:cpu-budget").unwrap(), clean_picker);
+ assert_eq!(h.app.session.doc, saved, "navigation keeps the saved camera until Update shot");
+ assert_eq!(h.app.session.undo.len(), undo);
+ inspector::restore_camera(&mut h.app).unwrap();
+ assert_eq!(h.app.cam, saved.render.setups["Studio"].camera);
}
#[test]
@@ -3819,7 +3939,7 @@ fn finishing_backdrop_and_raw_retention_save_reload_without_a_gpu_or_hidden_tran
assert_eq!(h.app.render_workspace.view.studio.finishing, Finishing::default());
assert!(h.app.render_workspace.view.studio.linear_exr);
assert!(h.app.render_workspace.view.studio.backdrop_enabled);
- assert!(h.app.render_workspace.view.dirty);
+ assert!(!h.app.render_workspace.view.dirty, "Effects already saved the numerical edit");
assert_ne!(h.app.session.doc.to_json(), before, "Effects saves its job patch through the shared editor");
let reset = setups::snapshot(&h.app).unwrap();
setups::load(&mut h.app);
@@ -3862,7 +3982,7 @@ fn render_workspace_stage_commands_keep_registered_actions_without_a_ribbon() {
assert!(crate::scenario::rect_of("tab:RENDER").is_none());
assert!(crate::scenario::rect_of("render:hud").is_none());
assert_eq!(h.app.render_workspace.view.stage, Stage::Look);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Scene);
}
#[test]
@@ -3873,11 +3993,12 @@ fn render_workspace_stage_chips_dispatch_without_mutations_and_remember_each_doc
let document = h.app.session.doc.clone();
let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
for stage in Stage::ALL {
+ let selection = h.app.render_workspace.view.selection.clone();
h.frames(3);
h.step(&json!({"click":{"handle":format!("render:stage:{}",stage.key())}})).unwrap();
h.frames(2);
assert_eq!(h.app.render_workspace.view.stage, stage);
- assert_eq!(h.app.render_workspace.view.inspector.page, stage.page());
+ assert_eq!(h.app.render_workspace.view.selection, selection);
assert_eq!(crate::scenario::rect_of("render:pick").is_some(), stage == Stage::Look);
assert_eq!(crate::scenario::rect_of("render:preview_note").is_some(), stage == Stage::Look);
assert!(Arc::ptr_eq(&h.app.session.doc, &document));
@@ -3888,7 +4009,7 @@ fn render_workspace_stage_chips_dispatch_without_mutations_and_remember_each_doc
for command in ["render.status", "render.backends"] {
h.app.start(command);
h.frames(2);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Diagnostics);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Check);
}
}
h.app.run("view.render_stage", json!({"stage":"frame"})).unwrap();
@@ -4269,6 +4390,10 @@ fn render_workspace_shots_toggle_persists_and_design_roundtrip_preserves_state()
h.call("ui.resize", json!({"width":1440,"height":1000}));
h.app.run("solid.box", json!({"length":20,"width":15,"height":10,"body_name":"Subject"})).unwrap();
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }];
+ {
+ let selection = object_selection(&h.app);
+ selection_editor(&mut h.app, &selection);
+ }
h.app.cam.yaw = 0.71;
h.app.cam.pitch = 0.23;
h.app.cam.roll = 0.17;
@@ -4415,7 +4540,7 @@ fn assert_product_fits_canvas(app: &SolveApp) {
fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() {
for (layout, page) in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked]
.into_iter()
- .flat_map(|layout| [inspector::Page::Scene, inspector::Page::Appearance].map(|page| (layout, page)))
+ .flat_map(|layout| [inspector::Editor::Scene, inspector::Editor::Appearance].map(|page| (layout, page)))
{
let mut h = Harness::new();
h.app.ui.layout = layout;
@@ -4424,7 +4549,7 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() {
h.frames(4);
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = page;
+ inspector::select_editor(&mut h.app, page);
h.frames(4);
let viewport = h.app.viewport.rect.unwrap();
let history = crate::timeline::floating_rect(viewport);
@@ -4465,7 +4590,7 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() {
"render:tree:by-look"
} else if key == "render:appearances" {
"render:library-search"
- } else if page == inspector::Page::Appearance {
+ } else if page == inspector::Editor::Appearance {
"dialog:editor_footer"
} else {
"render:scene:look"
@@ -4923,9 +5048,9 @@ fn render_lights_browser_sections_and_lights_describe_current_job_entries() {
assert_eq!(scene::environment(&h.app), ("Sky".into(), "90° · 2.50×".into()));
h.frames(3);
h.step(&json!({"click":{"handle":"render:tree:environment:current"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Environment);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Environment);
h.step(&json!({"click":{"browser":"Key"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Lighting);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Light);
}
#[test]
@@ -5045,24 +5170,23 @@ fn render_workspace_dock_grip_menus_dispatch_the_other_side() {
}
#[test]
-fn render_workspace_browser_shot_switch_keeps_the_existing_dirty_confirmation() {
+fn render_workspace_browser_shot_switch_preserves_saved_edits_without_a_draft_prompt() {
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1440,"height":1100}));
enter(&mut h.app, true).unwrap();
h.app.render_workspace.view.name = "A".into();
setups::save(&mut h.app).unwrap();
h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap();
+ let before = setups::draft(&h.app).unwrap();
h.app.render_workspace.view.draft.width = 123;
+ setups::persist_editor(&mut h.app, &before).unwrap();
h.frames(3);
h.step(&json!({"click":{"handle":"render:tree:shot:B"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.name, "A");
- assert!(inspector::confirmation_open(&h.app));
- h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap();
- assert_eq!(h.app.render_workspace.view.draft.width, 123);
- h.step(&json!({"click":{"handle":"render:tree:shot:B"}})).unwrap();
- h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap();
+ assert!(!inspector::confirmation_open(&h.app));
assert_eq!(h.app.render_workspace.view.name, "B");
assert_eq!(h.app.render_workspace.view.draft.width, 321);
+ assert_eq!(h.app.session.doc.render.setups["A"].width, 123);
+ assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Shot("B".into()));
assert!(!h.app.render_workspace.view.dirty);
}
@@ -5088,7 +5212,7 @@ fn render_lights_browser_focus_covers_each_kind_without_design_edits() {
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Object(vec![Sel::Body { name: "Object".into() }]));
h.step(&json!({"click":{"handle":"render:tree:environment"}})).unwrap();
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Environment);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Environment);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Environment);
assert!(crate::scenario::rect_of("dialog:section:Source").is_some());
assert!(h.app.session.selection.is_empty());
let focused_revision = h.app.session.revision;
@@ -5115,7 +5239,7 @@ fn render_lights_browser_focus_covers_each_kind_without_design_edits() {
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output);
h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Scene);
assert_eq!(h.app.session.revision, focused_revision, "semantic selection only refreshes the view when clearing object picks");
assert!(Arc::ptr_eq(&doc, &h.app.session.doc));
assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()));
@@ -5136,11 +5260,12 @@ fn render_lights_browser_eye_and_solo_are_view_state_and_editor_opening_is_read_
assert_eq!(h.app.render_workspace.view.lights.visibility.solo.as_deref(), Some("directional:1"));
h.step(&json!({"click":{"handle":"render:tree:light:1"}})).unwrap();
h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Lighting);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Light);
assert!(crate::scenario::rect_of("render:light:editor").is_some());
assert!(crate::scenario::handle_at("render:tree:shots:add").is_some());
h.step(&json!({"click":{"handle":"render:tree:shots:add"}})).unwrap();
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene);
+ assert!(inspector::confirmation_open(&h.app));
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Light);
assert!(Arc::ptr_eq(&document, &h.app.session.doc));
assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision, h.app.session.is_dirty()));
assert!(h.app.render_workspace.view.job.is_none());
@@ -5414,7 +5539,7 @@ fn render_workspace_shots_modified_dot_update_and_revert_follow_only_camera() {
enter(&mut h.app, true).unwrap();
h.frames(3);
setups::save(&mut h.app).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::Camera;
+ inspector::select_editor(&mut h.app, inspector::Editor::Camera);
h.frames(3);
assert!(!shots::camera_modified(&h.app, "Studio"));
assert!(crate::scenario::rect_of("dialog:list:shot:Studio:modified").is_none());
@@ -5425,8 +5550,8 @@ fn render_workspace_shots_modified_dot_update_and_revert_follow_only_camera() {
h.app.cam.yaw += 0.3;
h.frames(3);
assert!(crate::scenario::rect_of("dialog:list:shot:Studio:modified").is_some());
- assert!(crate::scenario::handle_at("render:shots:update").is_some());
- h.step(&json!({"click":{"handle":"render:shots:update"}})).unwrap();
+ assert!(crate::scenario::handle_at("render:shot:update").is_some());
+ h.step(&json!({"click":{"handle":"render:shot:update"}})).unwrap();
h.frames(2);
let mut expected = saved.clone();
expected.camera = h.app.cam;
@@ -5434,12 +5559,14 @@ fn render_workspace_shots_modified_dot_update_and_revert_follow_only_camera() {
assert_eq!(h.app.render_workspace.view.draft.width, 317, "Update must preserve the editor draft");
assert!(!shots::camera_modified(&h.app, "Studio"));
assert!(crate::scenario::rect_of("dialog:list:shot:Studio:modified").is_none());
- assert!(crate::scenario::handle_at("render:shots:update").is_none());
+ let tree = h.output.accesskit_update.as_ref().unwrap();
+ let update = tree.nodes.iter().find(|(_, node)| node.label() == Some(h.app.tr("render.shots_update"))).unwrap();
+ assert!(update.1.is_disabled(), "Update stays visible but inactive once the camera is saved");
h.app.cam.roll += 0.2;
h.frames(3);
let document = h.app.session.doc.clone();
let undo = h.app.session.undo.len();
- h.step(&json!({"click":{"handle":"render:shots:revert"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:shot:revert"}})).unwrap();
h.frames(2);
assert_eq!(h.app.cam, expected.camera);
assert!(!shots::camera_modified(&h.app, "Studio"));
@@ -6160,6 +6287,10 @@ fn render_assign_gestures_selection_sizes_are_atomic_and_undoable() {
}
h.app.run("select.filter", json!({"mode":"body"})).unwrap();
h.app.session.selection = vec![Sel::Body { name: "Plate".into() }, Sel::Body { name: "missing".into() }];
+ {
+ let selection = object_selection(&h.app);
+ selection_editor(&mut h.app, &selection);
+ }
let before = h.app.session.doc.to_json();
let undo = h.app.session.undo.len();
assert!(assign::tile(&mut h.app, json!({"appearance":"ABS - Red"}), false).is_err());
@@ -6207,6 +6338,10 @@ fn render_assign_gestures_paint_sample_copy_paste_escape_and_failed_pick() {
h.app.start("appearance.paint");
h.step(&json!({"key":"Escape"})).unwrap();
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Plate".into() }];
+ {
+ let selection = object_selection(&h.app);
+ selection_editor(&mut h.app, &selection);
+ }
h.app.start("appearance.copy");
h.app.run("appearance.assign", json!({"bodies":["Plate"],"appearance":"ABS - Yellow"})).unwrap();
let undo = h.app.session.undo.len();
@@ -6378,7 +6513,7 @@ fn render_lighting_group_selection_opens_ordered_editor_and_plus_still_adds() {
h.frames(3);
h.step(&json!({"click":{"handle":"render:tree:lights"}})).unwrap();
assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Lighting);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Lighting);
+ assert_eq!(inspector::selected_editor(&h.app), inspector::Editor::Lighting);
assert!(crate::scenario::rect_of("render:lighting:editor").is_some());
assert!(Arc::ptr_eq(&before, &h.app.session.doc));
let sections: Vec<_> = ["render.lighting_source_section", "render.lighting_shadows_section", "render.lighting_budget"]
@@ -6452,7 +6587,7 @@ fn render_assign_gestures_stage_tools_and_selection_actions_use_commands() {
assert!(h.app.render_workspace.view.assign.sampling);
h.step(&json!({"key":"Escape"})).unwrap();
h.step(&json!({"click":{"handle":"selection:action:0"}})).unwrap();
- assert!(crate::scenario::rect_of("render:look_chain").is_some());
+ assert!(crate::scenario::rect_of("render:appearance:chain-menu").is_some());
h.step(&json!({"click":{"handle":"selection:action:2"}})).unwrap();
assert_eq!(h.app.preferences.render_library_favorites.len(), 1);
h.step(&json!({"click":{"handle":"selection:action:2"}})).unwrap();
@@ -6564,7 +6699,6 @@ fn render_lights_each_kind_contains_design_sections_and_real_parameter_fields_in
h.app.run("render.settings.set", json!({"name":"Studio","set":{"job":{"method":method,"options":options}}})).unwrap();
setups::load(&mut h.app);
light::edit(&mut h.app, "render.lights.add", None, Some(json!({"kind":kind}))).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::Lighting;
let before = h.app.session.doc.clone();
h.frames(3);
assert!(crate::scenario::rect_of("render:light:editor").is_some());
@@ -6774,7 +6908,6 @@ fn render_lighting_hostile_numeric_edits_refuse_without_panics_or_partial_state(
assert!(Arc::ptr_eq(&before, &h.app.session.doc));
assert_eq!(h.app.session.undo.len(), history);
}
- h.app.render_workspace.view.inspector.page = inspector::Page::Lighting;
h.frames(3);
assert!(crate::scenario::rect_of("render:light:editor").is_some());
}