* Render appearance: click, drag and paint to assign, Pick Up, copy and paste, and Remove * Exclude the workspace Shots strip from dialog width checks * Exclude the collapsed Shots control from dialog width checks * Retain assembly cache listings and measure actual dialog bounds * fix: handle toast button rectangles in assignment status * fix: restrict gallery note measurement helper to tests * test: measure assignment help at the catalogue footer * fix: share the command revision snapshot after restacking
1286 lines
59 KiB
Rust
1286 lines
59 KiB
Rust
//! Contextual native Render UI. One workspace, existing command authority and shared controls.
|
||
//! Page navigation is per document; unsupported backend capabilities never emit dummy parameters.
|
||
use super::{ImageMethod, cpu, library, materials, setups, studio};
|
||
use crate::{SolveApp, ui_kit};
|
||
use serde_json::{Value, json};
|
||
use solidcraft_engine::doc::Document;
|
||
use std::sync::{Arc, Weak};
|
||
|
||
#[path = "render_ui/appearance.rs"]
|
||
mod selection_appearance;
|
||
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||
pub(super) enum Page {
|
||
#[default]
|
||
Scene,
|
||
Appearance,
|
||
Effects,
|
||
Lighting,
|
||
Environment,
|
||
Background,
|
||
Camera,
|
||
Output,
|
||
Diagnostics,
|
||
#[cfg(test)]
|
||
All,
|
||
}
|
||
impl Page {
|
||
#[cfg(test)]
|
||
const ALL: [Self; 10] = [
|
||
Self::Scene,
|
||
Self::Appearance,
|
||
Self::Lighting,
|
||
Self::Environment,
|
||
Self::Background,
|
||
Self::Camera,
|
||
Self::Effects,
|
||
Self::Output,
|
||
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::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::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::Diagnostics => "inspect",
|
||
#[cfg(test)]
|
||
Self::All => "list",
|
||
}
|
||
}
|
||
}
|
||
#[derive(Clone, Debug)]
|
||
pub(super) struct View {
|
||
pub effects: super::effects::View,
|
||
pub hidden: bool,
|
||
pub page: Page,
|
||
reveal: Option<&'static str>,
|
||
pending: Option<Pending>,
|
||
shot_name: String,
|
||
pub checked: Option<Review>,
|
||
scene_info: Option<Review>,
|
||
ground_margin: f64,
|
||
ground_gap: f64,
|
||
ground_color: [f64; 3],
|
||
appearance: Appearance,
|
||
selection_appearance: selection_appearance::View,
|
||
pub(super) resolution: Resolution,
|
||
}
|
||
/// Editor-only coupling. The fixed rational anchor prevents repeated rounded
|
||
/// edits drifting; external preset/shot changes deliberately establish a new anchor.
|
||
#[derive(Clone, Debug, Default)]
|
||
pub(super) struct Resolution {
|
||
locked: bool,
|
||
pub(super) custom: bool,
|
||
anchor: Option<[u32; 2]>,
|
||
observed: Option<[u32; 2]>,
|
||
rejected: bool,
|
||
}
|
||
impl Resolution {
|
||
fn observe(&mut self, size: [u32; 2]) {
|
||
if self.observed != Some(size) {
|
||
self.anchor = (size[0] > 0 && size[1] > 0).then_some(size);
|
||
self.observed = Some(size);
|
||
self.rejected = false;
|
||
}
|
||
}
|
||
fn edit(&mut self, before: [u32; 2], axis: usize, value: u32, maximum: u32) -> Option<[u32; 2]> {
|
||
self.observe(before);
|
||
let mut candidate = before;
|
||
*candidate.get_mut(axis)? = value;
|
||
if value == 0 || value > maximum {
|
||
self.rejected = true;
|
||
return None;
|
||
}
|
||
if self.locked {
|
||
let Some(anchor) = self.anchor else {
|
||
self.rejected = true;
|
||
return None;
|
||
};
|
||
let Some(other) = 1usize.checked_sub(axis) else {
|
||
self.rejected = true;
|
||
return None;
|
||
};
|
||
let denominator = u64::from(*anchor.get(axis)?);
|
||
let numerator = u64::from(value).checked_mul(u64::from(*anchor.get(other)?))?;
|
||
let paired = numerator.checked_add(denominator / 2)?.checked_div(denominator)?;
|
||
if paired == 0 || paired > u64::from(maximum) {
|
||
self.rejected = true;
|
||
return None;
|
||
}
|
||
*candidate.get_mut(other)? = u32::try_from(paired).ok()?;
|
||
} else {
|
||
self.anchor = (candidate[0] > 0 && candidate[1] > 0).then_some(candidate);
|
||
}
|
||
self.observed = Some(candidate);
|
||
self.rejected = false;
|
||
Some(candidate)
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
struct Pending {
|
||
action: PendingAction,
|
||
document: Weak<Document>,
|
||
revision: u64,
|
||
}
|
||
#[derive(Clone, Debug)]
|
||
enum PendingAction {
|
||
Switch(String),
|
||
ManageShot { name: String, command: String },
|
||
Reload,
|
||
Remove(String),
|
||
}
|
||
#[derive(Clone, Debug)]
|
||
pub(super) struct Review {
|
||
request: Value,
|
||
reply: Value,
|
||
revision: u64,
|
||
document: Weak<Document>,
|
||
}
|
||
impl Review {
|
||
fn current(&self, app: &SolveApp) -> bool {
|
||
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,
|
||
shot_name: String::new(),
|
||
checked: None,
|
||
scene_info: None,
|
||
ground_margin: 1.0,
|
||
ground_gap: 0.1,
|
||
ground_color: [0.18; 3],
|
||
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 output =
|
||
!wear && (app.render_workspace.view.inspector.page == Page::Output || app.render_workspace.view.selection == super::RenderSelection::Output);
|
||
let page = if output { Page::Output } else { app.render_workspace.view.inspector.page };
|
||
let appearance_editor = !wear && page == Page::Appearance;
|
||
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 {
|
||
app.tr(if output { "render.page_output" } 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 !appearance_editor && !output {
|
||
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 {
|
||
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::presentation_controls(app, ui),
|
||
Page::Lighting => lighting_controls(app, ui),
|
||
Page::Environment | Page::Background => super::environment::editor(app, ui),
|
||
Page::Camera => camera_controls(app, ui),
|
||
Page::Output => output_editor(app, ui),
|
||
Page::Diagnostics => diagnostics(app, ui),
|
||
#[cfg(test)]
|
||
Page::All => {
|
||
ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help"));
|
||
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", ¤t, |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));
|
||
}
|
||
|
||
pub(super) fn shot_row_action(app: &mut SolveApp, name: String, command: &str) {
|
||
setups::refresh_dirty(app);
|
||
if command == "render.shot.remove" {
|
||
request_action(app, PendingAction::Remove(name));
|
||
} else {
|
||
request_action(app, PendingAction::ManageShot { name, command: command.into() });
|
||
}
|
||
}
|
||
|
||
fn request_action(app: &mut SolveApp, action: PendingAction) {
|
||
if 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) {
|
||
app.set_status(error, true);
|
||
}
|
||
}
|
||
fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), String> {
|
||
match action {
|
||
PendingAction::Switch(name) => {
|
||
app.render_workspace.view.name = name;
|
||
setups::load(app);
|
||
}
|
||
PendingAction::ManageShot { name, command } => {
|
||
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 {
|
||
app.render_workspace.view.name = app.session.doc.render.setups.keys().next().cloned().unwrap_or_else(|| "Studio".into());
|
||
setups::load(app);
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
|
||
super::shots::confirmation(app, ctx);
|
||
materials::confirmation(app, ctx);
|
||
let Some(pending) = app.render_workspace.view.inspector.pending.clone() else { return };
|
||
if pending.revision != app.session.revision || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc)) {
|
||
app.render_workspace.view.inspector.pending = None;
|
||
app.set_status(app.tr("render.review_stale").to_string(), true);
|
||
return;
|
||
}
|
||
let removing = matches!(&pending.action, PendingAction::Remove(_));
|
||
let title = app.tr(if removing { "render.shot_remove_title" } else { "render.draft_confirm_title" }).to_string();
|
||
let keep = app.tr(if removing { "render.stage_panels.keep" } else { "render.keep_editing" }).to_string();
|
||
let primary = app.tr(if removing { "render.stage_panels.remove_shot" } else { "render.save_continue" }).to_string();
|
||
let discard = app.tr("render.discard_continue").to_string();
|
||
let message = app.tr(if removing { "render.shot_remove_help" } else { "render.draft_confirm_help" }).to_string();
|
||
let (closed, answer) = ui_kit::Confirm::new(egui::Id::new("render_pending_shot"), if removing { "delete" } else { "save" }, &title)
|
||
.tone(if removing { ui_kit::Tone::Danger } else { ui_kit::Tone::Warning })
|
||
.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);
|
||
});
|
||
if closed || answer == ui_kit::Action::Cancel {
|
||
app.render_workspace.view.inspector.pending = None;
|
||
return;
|
||
}
|
||
if answer == ui_kit::Action::None {
|
||
return;
|
||
}
|
||
if answer == ui_kit::Action::Ok
|
||
&& !removing
|
||
&& let Err(error) = setups::save(app)
|
||
{
|
||
app.set_status(error, true);
|
||
return;
|
||
}
|
||
app.render_workspace.view.inspector.pending = None;
|
||
if let Err(error) = perform_action(app, pending.action) {
|
||
app.set_status(error, true);
|
||
}
|
||
}
|
||
fn browse_button(app: &mut SolveApp, ui: &mut egui::Ui, kind: &str, key: &str) {
|
||
if ui_kit::button(ui, app.tr(key), ui_kit::Button::Normal).clicked() {
|
||
library::open_category(app, kind);
|
||
}
|
||
}
|
||
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"));
|
||
browse_button(app, ui, "native_scenes", "render.browse_native_scenes");
|
||
browse_button(app, ui, "scenes", "render.browse_scene_specs");
|
||
physical_stage_controls(app, ui);
|
||
shot_controls(app, ui);
|
||
}
|
||
fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let title = app.tr("render.passive_stage").to_string();
|
||
reveal_section(app, ui, "render_ground_details");
|
||
ui_kit::section(ui, "render_ground_details", &title, false, |ui| {
|
||
ui.label(app.tr("render.ground_margin"));
|
||
ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_margin, 0.0..=10.0, 0.05, " x");
|
||
ui.label(app.tr("render.ground_gap"));
|
||
ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_gap, 0.0001..=1000.0, 0.01, " mm");
|
||
let label = app.tr("render.ground_linear_rgb").to_string();
|
||
vector(ui, &label, &mut app.render_workspace.view.inspector.ground_color, 0.0..=1.0, 0.01);
|
||
let saved = setups::snapshot(app);
|
||
if ui_kit::button(
|
||
ui,
|
||
app.tr("render.ground_apply"),
|
||
ui_kit::Button::Enabled(saved.is_ok() && app.render_workspace.view.method != ImageMethod::Raster),
|
||
)
|
||
.clicked()
|
||
&& let Ok(set) = saved
|
||
{
|
||
let v = &app.render_workspace.view.inspector;
|
||
let request = json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":v.ground_margin,"gap_mm":v.ground_gap,"reflectance_linear":v.ground_color,"replace_stage":true});
|
||
library::review::command(app, "render.stage.ground", request);
|
||
}
|
||
ui_kit::text(ui, app.tr("render.physical_background_help"), ui_kit::Text::Note("render.physical_background_help"));
|
||
for (kind, key) in [("floor_wall", "render.physical_floor_wall"), ("cyclorama", "render.physical_cyclorama")] {
|
||
let set = setups::snapshot(app);
|
||
let button =
|
||
ui_kit::button(ui, app.tr(key), ui_kit::Button::Enabled(set.is_ok() && app.render_workspace.view.method != ImageMethod::Raster));
|
||
crate::scenario::publish_target(&format!("render:stage-{kind}"), button.rect);
|
||
if button.clicked()
|
||
&& let Ok(set) = set
|
||
{
|
||
let v = &app.render_workspace.view.inspector;
|
||
let p = json!({"name":app.render_workspace.view.name,"set":set,"kind":kind,"expected_revision":app.session.revision,
|
||
"replace_stage":true,"reflectance_linear":v.ground_color});
|
||
library::review::command(app, "render.stage.backdrop", p);
|
||
}
|
||
}
|
||
library::stage_content(app, ui);
|
||
});
|
||
}
|
||
|
||
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) {
|
||
browse_button(app, ui, "rigs", "render.browse_rigs");
|
||
|
||
match app.render_workspace.view.method {
|
||
ImageMethod::GpuRaytrace => studio::lighting_controls(app, ui),
|
||
ImageMethod::CpuRaytrace => {
|
||
super::cpu_lighting_controls(app, ui);
|
||
cpu::light_controls(app, ui);
|
||
}
|
||
ImageMethod::Raster => {
|
||
ui_kit::text(ui, app.tr("render.method_limit_raster"), ui_kit::Text::Note("render.method_limit_raster"));
|
||
}
|
||
}
|
||
}
|
||
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}))?;
|
||
app.follow_view_request(false);
|
||
app.render_workspace.view.dirty = true;
|
||
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() {
|
||
camera.fov = if perspective { std::f64::consts::FRAC_PI_4 } 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);
|
||
}
|
||
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);
|
||
}
|
||
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;
|
||
}
|
||
}
|
||
}
|
||
fn output_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
for (id, key, draw) in [
|
||
("render_output_image", "render.output_image", output_controls as fn(&mut SolveApp, &mut egui::Ui)),
|
||
("render_output_effects", "render.output_effects", super::effects::presentation_controls),
|
||
("render_output_check", "render.output_check", check_controls),
|
||
] {
|
||
reveal_section(app, ui, id);
|
||
let title = app.tr(key).to_string();
|
||
ui_kit::section(ui, id, &title, id != "render_output_effects", |ui| draw(app, ui));
|
||
}
|
||
}
|
||
fn check_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let ready = super::ribbon::action_ready(app, "render.preflight");
|
||
let check = ui_kit::button(ui, app.tr("render.output_check"), ui_kit::Button::Enabled(ready.is_ok()));
|
||
crate::scenario::publish_target("render:check", check.rect);
|
||
if check.clicked() {
|
||
app.start("render.preflight");
|
||
}
|
||
if let Err(reason) = ready {
|
||
check.on_disabled_hover_text(reason);
|
||
}
|
||
output_check(app, ui);
|
||
let title = app.tr("cmd.render_backends").to_string();
|
||
ui_kit::section(ui, "render_output_backends", &title, false, |ui| {
|
||
gpu_status(app, ui);
|
||
let backend = app.session.render_backend();
|
||
ui_kit::text(ui, &backend.label, ui_kit::Text::Inline);
|
||
for executor in backend.executors.iter().take(16) {
|
||
let status = match &executor.availability {
|
||
super::Availability::Available => app.tr("render.output_backend_ready"),
|
||
super::Availability::Unavailable { reason } => reason,
|
||
};
|
||
let label = format!("{} · {status}", executor.id.as_str());
|
||
ui_kit::text(ui, &label, ui_kit::Text::Report(executor.id.as_str(), false));
|
||
}
|
||
if let Some(job) = app.render_workspace.view.job
|
||
&& let Ok(status) = app.session.execute("render.status", &json!({"job":job}))
|
||
&& let Some(phase) = status["progress"]["phase"].as_str()
|
||
{
|
||
ui_kit::text(ui, app.tr(&format!("render.image_{phase}")), ui_kit::Text::Inline);
|
||
}
|
||
});
|
||
let title = app.tr("render.page_diagnostics").to_string();
|
||
ui_kit::section(ui, "render_output_diagnostics", &title, false, |ui| diagnostics(app, ui));
|
||
}
|
||
|
||
fn output_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let side = match app.render_workspace.view.method {
|
||
ImageMethod::CpuRaytrace => 16384,
|
||
ImageMethod::GpuRaytrace => 8192,
|
||
ImageMethod::Raster => 4096,
|
||
};
|
||
let before = [app.render_workspace.view.draft.width, app.render_workspace.view.draft.height];
|
||
app.render_workspace.view.inspector.resolution.observe(before);
|
||
let mut width = before[0];
|
||
let mut height = before[1];
|
||
let [w, h] = ui_kit::number_pair(ui, app.tr("render.output_dimensions"), [&mut width, &mut height], 1..=side, 1.0, "");
|
||
crate::scenario::publish_target("render:output-width", w.rect);
|
||
crate::scenario::publish_target("render:output-height", h.rect);
|
||
let edit = if w.changed() {
|
||
Some((0, width))
|
||
} else if h.changed() {
|
||
Some((1, height))
|
||
} else {
|
||
None
|
||
};
|
||
if let Some((axis, value)) = edit
|
||
&& let Some([width, height]) = app.render_workspace.view.inspector.resolution.edit(before, axis, value, side)
|
||
&& let Err(error) = app.run("render.output.size", json!({"width":width,"height":height,"custom":true}))
|
||
{
|
||
app.render_workspace.view.inspector.resolution.observe(before);
|
||
app.render_workspace.view.inspector.resolution.rejected = true;
|
||
app.set_status(error, true);
|
||
}
|
||
if app.render_workspace.view.inspector.resolution.rejected {
|
||
ui_kit::text(ui, app.tr("render.output_ratio_refused"), ui_kit::Text::Error("render.output_ratio_refused"));
|
||
}
|
||
let largest = largest_output(app);
|
||
let (w, h) = largest.map_or_else(|| ("—".to_string(), "—".to_string()), |(w, h)| (w.to_string(), h.to_string()));
|
||
let largest_label = crate::i18n::format("render.output_largest", &[("width", &w), ("height", &h)]);
|
||
for choices in [
|
||
("720", crate::i18n::tr("render.size_hd").to_string(), Some((1280, 720))),
|
||
("1080", crate::i18n::tr("render.size_full_hd").to_string(), Some((1920, 1080))),
|
||
("4k", crate::i18n::tr("render.size_4k_uhd").to_string(), Some((3840, 2160))),
|
||
("largest", largest_label, largest),
|
||
]
|
||
.chunks(2)
|
||
{
|
||
ui_kit::catalog_scope(ui, |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
for (key, label, size) in choices {
|
||
let allowed = size.filter(|&(w, h)| cpu::image_limits(app).fit(w, h, None) == Some((w, h)));
|
||
let response = ui
|
||
.add_enabled_ui(allowed.is_some(), |ui| {
|
||
ui_kit::choice_chip(ui, key, label, *size == Some((u64::from(before[0]), u64::from(before[1]))))
|
||
})
|
||
.inner;
|
||
crate::scenario::publish_target(&format!("render:size:{key}"), response.rect);
|
||
if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked()
|
||
&& let Some((w, h)) = allowed
|
||
{
|
||
let _ = app.run("render.output.size", json!({"width":w,"height":h}));
|
||
}
|
||
}
|
||
})
|
||
});
|
||
}
|
||
studio::export_controls(app, ui);
|
||
ui_kit::text(ui, app.tr("render.output_quality"), ui_kit::Text::Inline);
|
||
quality_choices(app, ui);
|
||
ui.scope(|ui| super::method_selector(app, ui)).response.on_hover_text(app.tr("render.method_limit_raster"));
|
||
let size = (u64::from(app.render_workspace.view.draft.width), u64::from(app.render_workspace.view.draft.height));
|
||
if cpu::image_limits(app).fit(size.0, size.1, None) != Some(size) {
|
||
ui_kit::text(ui, app.tr("render.output_over_budget"), ui_kit::Text::Error("render.output_over_budget"));
|
||
}
|
||
match app.render_workspace.view.method {
|
||
ImageMethod::GpuRaytrace => {
|
||
super::transport::sampling_controls(app, ui);
|
||
let label = app.tr("render.image_samples").to_string();
|
||
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.samples, 1..=4096, 1.0, ""));
|
||
let label = app.tr("render.gpu_depth").to_string();
|
||
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.max_depth, 1..=16, 1.0, ""));
|
||
let label = app.tr("render.gpu_seed").to_string();
|
||
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.seed, 0..=u32::MAX, 1.0, ""));
|
||
}
|
||
ImageMethod::CpuRaytrace => super::cpu_sampling_controls(app, ui),
|
||
ImageMethod::Raster => {}
|
||
}
|
||
if app.render_workspace.view.method != ImageMethod::Raster {
|
||
let label = app.tr("render.image_exposure").to_string();
|
||
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"));
|
||
}
|
||
let label = app.tr("render.image_transparent").to_string();
|
||
ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.transparent);
|
||
|
||
let label = app.tr("render.image_overwrite").to_string();
|
||
ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.overwrite);
|
||
let label = app.tr("render.output_destination").to_string();
|
||
let export = ui_kit::row(ui, &label, |ui| {
|
||
ui_kit::button(ui, studio::export_label(app), ui_kit::Button::Enabled(super::ribbon::action_ready(app, "render.export").is_ok()))
|
||
});
|
||
if export.on_hover_text(app.tr("render.output_destination_help")).clicked() {
|
||
app.start("render.export");
|
||
}
|
||
if app.render_workspace.view.completed.is_some() && ui_kit::button(ui, app.tr("render.output_view_image"), ui_kit::Button::Normal).clicked() {
|
||
let _ = app.run("render.result.view", json!({"view":"image"}));
|
||
}
|
||
reveal_section(app, ui, "render_output_advanced");
|
||
let title = app.tr("render.output_advanced").to_string();
|
||
ui_kit::section(ui, "render_output_advanced", &title, false, |ui| {
|
||
let label = app.tr("render.output_lock_ratio").to_string();
|
||
let lock = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.resolution.locked);
|
||
crate::scenario::publish_target("render:aspect-lock", lock.rect);
|
||
let swap = ui_kit::button(ui, app.tr("render.output_swap_orientation"), ui_kit::Button::Normal);
|
||
crate::scenario::publish_target("render:swap-size", swap.rect);
|
||
if swap.clicked() {
|
||
let _ = app.run("render.output.size", json!({"width":before[1],"height":before[0],"custom":true}));
|
||
let draft = &app.render_workspace.view.draft;
|
||
app.render_workspace.view.inspector.resolution.observe([draft.width, draft.height]);
|
||
}
|
||
ui_kit::text(ui, app.tr("render.output_format_status"), ui_kit::Text::Note("render.output_format_status"));
|
||
browse_button(app, ui, "quality", "render.browse_quality");
|
||
library::inspect_kinds(app, ui, &["quality"]);
|
||
ui_kit::text(ui, app.tr("render.adaptive_pending"), ui_kit::Text::Note("render.adaptive_pending"));
|
||
});
|
||
}
|
||
|
||
/// Fit an oversized same-aspect candidate, since fit deliberately never upscales.
|
||
pub(super) fn largest_output(app: &SolveApp) -> Option<(u64, u64)> {
|
||
let limits = cpu::image_limits(app);
|
||
let draft = &app.render_workspace.view.draft;
|
||
limits.fit(u64::from(draft.width).checked_mul(limits.max_dimension)?, u64::from(draft.height).checked_mul(limits.max_dimension)?, None)
|
||
}
|
||
pub(super) fn quality_choices(app: &SolveApp, ui: &mut egui::Ui) {
|
||
let reason = app.tr("render.output_quality_waiting");
|
||
let labels = ["render.quality_draft", "render.quality_balanced", "render.quality_high", "render.quality_custom"].map(|key| app.tr(key));
|
||
let mut quality = 3;
|
||
ui_kit::segmented(
|
||
ui,
|
||
&mut quality,
|
||
&labels,
|
||
ui_kit::Segments {
|
||
workspace_accent: true,
|
||
intrinsic: true,
|
||
compact: true,
|
||
disabled_reasons: &[Some(reason), Some(reason), Some(reason), None],
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
pub(super) fn check_summary(app: &SolveApp) -> String {
|
||
let state = match &app.render_workspace.view.inspector.checked {
|
||
Some(check) if check.current(app) && super::image_params(app).as_ref().ok() == Some(&check.request) => {
|
||
let count = check.reply["warnings"].as_array().map_or(0, Vec::len)
|
||
+ usize::from(check.reply["transparency"].as_str().is_some_and(|value| value != "physical_transmission"));
|
||
return crate::i18n::format("render.output_check_summary", &[("count", &count.to_string())]);
|
||
}
|
||
Some(_) => "render.studio_needs_review",
|
||
None => return app.tr("render.output_check").into(),
|
||
};
|
||
format!("{} · {}", app.tr("render.output_check"), app.tr(state))
|
||
}
|
||
|
||
const SIZE_PRESETS: [(&str, &str, Option<(u32, u32)>); 5] = [
|
||
("720", "render.size_preview", Some((1280, 720))),
|
||
("1080", "render.size_full_hd", Some((1920, 1080))),
|
||
("4k", "render.size_4k", Some((3840, 2160))),
|
||
("square", "render.size_square", Some((2048, 2048))),
|
||
("custom", "render.size_custom", None),
|
||
];
|
||
fn choose_size(app: &mut SolveApp, size: Option<(u32, u32)>) {
|
||
let custom = size.is_none();
|
||
let (width, height) = size.unwrap_or((app.render_workspace.view.draft.width, app.render_workspace.view.draft.height));
|
||
if let Err(error) = app.run("render.output.size", json!({"width":width,"height":height,"custom":custom})) {
|
||
app.set_status(error, true);
|
||
} else if custom {
|
||
let _ = app.run("view.render_select", json!({"kind":"output"}));
|
||
reveal(app, "render_output_image");
|
||
}
|
||
}
|
||
pub(super) fn size_presets(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
ui_kit::scope(ui, |ui| {
|
||
let current = (app.render_workspace.view.draft.width, app.render_workspace.view.draft.height);
|
||
let custom = app.render_workspace.view.inspector.resolution.custom || !SIZE_PRESETS.iter().any(|(_, _, size)| *size == Some(current));
|
||
for (key, label, size) in SIZE_PRESETS {
|
||
let summary = size.map_or_else(String::new, |(w, h)| format!("{w} × {h}"));
|
||
let enabled =
|
||
size.is_none_or(|(w, h)| cpu::image_limits(app).fit(u64::from(w), u64::from(h), None) == Some((u64::from(w), u64::from(h))));
|
||
let response = ui
|
||
.add_enabled_ui(enabled, |ui| {
|
||
ui_kit::settings_choice_row(
|
||
ui,
|
||
&ui_kit::SettingsChoice {
|
||
key: &format!("render:preset:{key}"),
|
||
title: app.tr(label),
|
||
summary: &summary,
|
||
detail: app.tr(label),
|
||
},
|
||
if size.is_none() { custom } else { !custom && size == Some(current) },
|
||
)
|
||
})
|
||
.inner;
|
||
if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked() {
|
||
choose_size(app, size);
|
||
}
|
||
}
|
||
ui_kit::text(ui, app.tr("render.output_presets_help"), ui_kit::Text::Note("render.output_presets_help"));
|
||
});
|
||
}
|
||
pub(super) fn stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let (size, _) = super::output_summary(app);
|
||
let dropdown = ui_kit::compact_dropdown_menu(ui, "render_stage_size", &size, |ui| {
|
||
for (key, label, size) in SIZE_PRESETS {
|
||
let enabled =
|
||
size.is_none_or(|(w, h)| cpu::image_limits(app).fit(u64::from(w), u64::from(h), None) == Some((u64::from(w), u64::from(h))));
|
||
let response = ui.add_enabled_ui(enabled, |ui| ui_kit::list_picker(ui, key, app.tr(label), false)).inner;
|
||
crate::scenario::publish_target(&format!("render:stage:size:{key}"), response.rect);
|
||
if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked() {
|
||
choose_size(app, size);
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
crate::scenario::publish_target("render:stage:size", dropdown.rect);
|
||
studio::format_choices(app, ui);
|
||
quality_choices(app, ui);
|
||
let summary = check_summary(app);
|
||
let response = ui_kit::choice_chip(ui, "render_stage_check", &summary, false).on_hover_text(app.tr("render.output_check_help"));
|
||
crate::scenario::publish_target("render:stage:check", response.rect);
|
||
if response.clicked() {
|
||
app.start("render.preflight");
|
||
}
|
||
}
|
||
|
||
fn output_check(app: &SolveApp, ui: &mut egui::Ui) {
|
||
let Some(check) = &app.render_workspace.view.inspector.checked else {
|
||
ui_kit::text(ui, app.tr("render.output_check_help"), ui_kit::Text::Note("render.output_check_help"));
|
||
return;
|
||
};
|
||
if !check.current(app) || super::image_params(app).as_ref().ok() != Some(&check.request) {
|
||
ui_kit::check_line(ui, "render:check:stale", app.tr("render.review_stale"), true);
|
||
return;
|
||
}
|
||
ui_kit::check_line(ui, "render:check:ready", app.tr("render.output_ready"), false);
|
||
if let (Some(w), Some(h)) = (check.reply["request"]["width"].as_u64(), check.reply["request"]["height"].as_u64()) {
|
||
let label = crate::i18n::format("render.output_size_ok", &[("width", &w.to_string()), ("height", &h.to_string())]);
|
||
ui_kit::check_line(ui, "render:check:size", &label, false);
|
||
}
|
||
if let Some(transparency) = check.reply["transparency"].as_str() {
|
||
let key = match transparency {
|
||
"physical_transmission" => "render.check_transmission",
|
||
"opaque_only" => "render.check_opaque",
|
||
_ => "render.check_sorted_alpha",
|
||
};
|
||
ui_kit::check_line(ui, "render:check:transparency", app.tr(key), transparency != "physical_transmission");
|
||
}
|
||
if let Some(warnings) = check.reply["warnings"].as_array() {
|
||
for warning in warnings.iter().take(32) {
|
||
ui_kit::check_line(ui, "render:check:warning", &warning.to_string(), true);
|
||
}
|
||
}
|
||
}
|
||
|
||
pub(super) fn scene_resource(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
|
||
if ui_kit::button(ui, app.tr("render.scene_review"), ui_kit::Button::Enabled(app.render_workspace.view.method == ImageMethod::GpuRaytrace))
|
||
.clicked()
|
||
{
|
||
let mut view = library::View::default();
|
||
if let Err(error) = library::choose(app, &mut view, "native_scenes", id).and_then(|()| library::review::light(app, &view, id)) {
|
||
app.set_status(error, true);
|
||
}
|
||
}
|
||
}
|
||
pub(super) fn quality_resource(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
|
||
ui_kit::text(ui, app.tr("render.quality_projection_help"), ui_kit::Text::Note("render.quality_projection_help"));
|
||
if ui_kit::button(ui, app.tr("render.quality_review"), ui_kit::Button::Enabled(app.render_workspace.view.method == ImageMethod::GpuRaytrace))
|
||
.clicked()
|
||
&& let Err(error) = library::review::quality(app, id)
|
||
{
|
||
app.set_status(error, true);
|
||
}
|
||
}
|
||
pub(super) fn apply_quality(app: &mut SolveApp, plan: &Value) -> Result<(), String> {
|
||
if app.render_workspace.view.method != ImageMethod::GpuRaytrace || plan["variant"] != "fixed_samples_png" {
|
||
return Err(crate::i18n::tr("render.error_quality_method").into());
|
||
}
|
||
let u32_at = |section: &str, key: &str| {
|
||
plan[section][key].as_u64().and_then(|n| u32::try_from(n).ok()).ok_or_else(|| crate::i18n::tr("render.error_quality_projection").to_string())
|
||
};
|
||
let (width, height, samples, depth, seed) = (
|
||
u32_at("settings", "width")?,
|
||
u32_at("settings", "height")?,
|
||
u32_at("gpu_options", "samples")?,
|
||
u32_at("gpu_options", "max_depth")?,
|
||
u32_at("gpu_options", "seed")?,
|
||
);
|
||
let denoise = plan["gpu_options"]["denoise"].as_bool().ok_or(crate::i18n::tr("render.error_denoise_setting"))?;
|
||
if !(1..=4096).contains(&samples)
|
||
|| !(1..=16).contains(&depth)
|
||
|| solidcraft_engine::render::job::GPU_PATH_LIMITS.fit(u64::from(width), u64::from(height), None)
|
||
!= Some((u64::from(width), u64::from(height)))
|
||
{
|
||
return Err(crate::i18n::tr("render.error_quality_bounds").into());
|
||
}
|
||
let view = &mut app.render_workspace.view;
|
||
view.draft.width = width;
|
||
view.draft.height = height;
|
||
view.samples = samples;
|
||
view.max_depth = depth;
|
||
view.seed = seed;
|
||
view.studio.denoise = denoise;
|
||
view.dirty = true;
|
||
Ok(())
|
||
}
|
||
fn diagnostics(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
if let Some(bytes) = app.render_workspace.preview_upload_bytes {
|
||
ui.label(format!("{}: {:.2} / {} MiB", app.tr("render.preview_upload"), bytes as f64 / 1048576.0, super::MAX_GEOMETRY_BYTES / 1048576));
|
||
ui_kit::text(ui, app.tr("render.preview_upload_help"), ui_kit::Text::Note("render.preview_upload_help"));
|
||
}
|
||
if let Some(error) = &app.render_workspace.scene_error {
|
||
ui_kit::text(ui, error, ui_kit::Text::Error("render.preview_cached_error"));
|
||
}
|
||
let request = super::image_request(app);
|
||
ui.strong(app.tr(app.render_workspace.view.method.label()));
|
||
if let Err(error) = super::image_params(app) {
|
||
ui_kit::text(ui, &error.to_string(), ui_kit::Text::Error("render.native-error"));
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.inspect_scene"), ui_kit::Button::Normal).clicked() {
|
||
match app.run("render.scene", json!({})) {
|
||
Ok(reply) => {
|
||
app.render_workspace.view.inspector.scene_info =
|
||
Some(Review { request: json!({}), reply, revision: app.session.revision, document: Arc::downgrade(&app.session.doc) })
|
||
}
|
||
Err(error) => app.set_status(error, true),
|
||
}
|
||
}
|
||
if let Some(info) = &app.render_workspace.view.inspector.scene_info {
|
||
if !info.current(app) {
|
||
ui_kit::text(ui, app.tr("render.review_stale"), ui_kit::Text::Note("render.review_stale"));
|
||
}
|
||
let bodies = info.reply["bodies"].as_array();
|
||
let count = bodies.map_or(0, Vec::len);
|
||
let triangles = bodies.map_or(0, |b| b.iter().filter_map(|v| v["triangles"].as_u64()).sum::<u64>());
|
||
ui.label(format!("{}: {count} / {}: {triangles}", app.tr("render.diag_bodies"), app.tr("render.diag_triangles")));
|
||
}
|
||
if let Some(check) = &app.render_workspace.view.inspector.checked {
|
||
ui.strong(app.tr("render.diag_last_check"));
|
||
if !check.current(app) || request.as_ref().ok() != Some(&check.request) {
|
||
ui_kit::text(ui, app.tr("render.review_stale"), ui_kit::Text::Note("render.review_stale"));
|
||
}
|
||
if let Some(bytes) = check.reply["admission"]["estimated_total_bytes"].as_u64() {
|
||
ui.label(format!("{}: {:.2} MiB", app.tr("render.diag_memory"), bytes as f64 / 1048576.0));
|
||
}
|
||
if let Some(warnings) = check.reply["warnings"].as_array() {
|
||
for warning in warnings {
|
||
ui_kit::text(ui, &warning.to_string(), ui_kit::Text::Note("render.native-warning"));
|
||
}
|
||
}
|
||
let detail = check.reply.clone();
|
||
json_details(app, ui, "render.diag_preflight_details", &detail);
|
||
}
|
||
if let Some(job) = app.render_workspace.view.job
|
||
&& let Ok(status) = app.session.execute("render.status", &json!({"job":job}))
|
||
{
|
||
if let Some(error) = status["error"]["message"].as_str() {
|
||
ui_kit::text(ui, error, ui_kit::Text::Error("render.native-error"));
|
||
}
|
||
json_details(app, ui, "render.diag_job_details", &status);
|
||
}
|
||
if let Ok(request) = &request {
|
||
json_details(app, ui, "render.diag_request", request);
|
||
}
|
||
ui.separator();
|
||
ui.strong(app.tr("render.diag_not_implemented"));
|
||
for key in
|
||
["render.adaptive_pending", "render.exr_pending", "render.transmission_scope", "render.advanced_material_scope", "render.queue_pending"]
|
||
{
|
||
ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
|
||
}
|
||
browse_button(app, ui, "capabilities", "render.browse_capabilities");
|
||
library::inspect_kinds(app, ui, &["capabilities"]);
|
||
}
|
||
fn json_details(app: &SolveApp, ui: &mut egui::Ui, key: &str, value: &Value) {
|
||
let title = app.tr(key).to_string();
|
||
ui_kit::section(ui, key, &title, false, |ui| {
|
||
let text = serde_json::to_string_pretty(value).unwrap_or_default();
|
||
if ui_kit::button(ui, app.tr("render.copy_request"), ui_kit::Button::Normal).clicked() {
|
||
ui.ctx().copy_text(text.clone());
|
||
}
|
||
egui::ScrollArea::vertical().max_height(280.0).show(ui, |ui| {
|
||
ui.monospace(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;
|
||
|
||
pub(super) fn fit_subject(app: &mut SolveApp) -> Result<(), String> {
|
||
// Capture the current navigation orientation before the engine's view command.
|
||
app.run("render.camera.set", json!({"camera":app.cam}))?;
|
||
app.run("render.camera.fit", json!({}))?;
|
||
app.follow_view_request(false);
|
||
app.fit_view();
|
||
Ok(())
|
||
}
|
||
|
||
pub(super) fn restore_camera(app: &mut SolveApp) -> Result<(), String> {
|
||
let name = app.render_workspace.view.name.clone();
|
||
app.run("render.settings.apply", json!({"name":name}))?;
|
||
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()
|
||
|| materials::confirmation_open(app)
|
||
|| library::review_open(app)
|
||
|| super::assign::replacement_open(app)
|
||
}
|
||
pub(super) fn reveal(app: &mut SolveApp, section: &'static str) {
|
||
app.render_workspace.view.inspector.reveal = Some(section);
|
||
}
|
||
fn reveal_section(app: &mut SolveApp, ui: &mut egui::Ui, section: &'static str) {
|
||
if app.render_workspace.view.inspector.reveal == Some(section) {
|
||
let identity = ui.make_persistent_id(section);
|
||
ui.ctx().data_mut(|data| data.insert_persisted(identity, true));
|
||
ui.scroll_to_cursor(Some(egui::Align::Min));
|
||
app.render_workspace.view.inspector.reveal = None;
|
||
}
|
||
}
|
||
|
||
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 => {
|
||
ui_kit::text(ui, app.tr("render.gpu_unavailable"), ui_kit::Text::Note("render.gpu_unavailable"));
|
||
}
|
||
super::PathHost::Ready(_) => {}
|
||
}
|
||
}
|