SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Integrated product preview. Shares the installed device/pipelines, not Design's scene policy.
use crate::ui_kit::BackingTooltipExt as _;
use solidcraft_engine::geom::prelude::*;
use std::hash::{Hash, Hasher};
use std::sync::{Arc, Mutex};
use egui::Sense;
use serde_json::json;
use solidcraft_engine::doc::render_settings::RenderSetup;
#[cfg(test)]
use solidcraft_engine::render::job::LightingPreset;
use solidcraft_engine::render::job::{ImageHost, Integrator, PreviewInfo, RaytraceOptions};
use solidcraft_engine::render::{
Availability, Camera, ExecutorDescriptor, ExecutorId, ProductScene, RenderLimits, RenderMode, RenderOperation, RenderProfile, RenderRequest,
ScratchLayout,
};
use crate::gpu::{Frame, GpuScene, SceneSlot, ViewportCallback};
use crate::{SolveApp, theme::Tokens};
// Vertex payload only, not an OS/GPU peak-memory promise. Native viewport
// uploads are already chunked by the installed device's buffer limit.
const MAX_GEOMETRY_BYTES: usize =
if cfg!(all(not(target_arch = "wasm32"), target_pointer_width = "64")) { 512 * 1024 * 1024 } else { 128 * 1024 * 1024 };
#[path = "render_workspace_ribbon.rs"]
mod ribbon;
#[path = "render_workspace_compare.rs"]
mod compare;
#[path = "render_workspace_cpu.rs"]
mod cpu;
#[path = "render_workspace_hdr.rs"]
mod hdr;
#[path = "render_workspace_effects.rs"]
mod effects;
#[path = "render_workspace_environment.rs"]
mod environment;
#[path = "render_workspace_output.rs"]
mod inspector;
#[path = "render_ui/inspector.rs"]
mod inspector_panel;
#[path = "render_workspace_library.rs"]
mod library;
#[path = "render_ui/assign.rs"]
pub(crate) mod assign;
#[path = "render_workspace_displayed.rs"]
pub(crate) mod displayed;
#[path = "render_workspace_light.rs"]
pub(crate) mod light;
#[path = "render_workspace_live.rs"]
pub(crate) mod live;
#[path = "render_workspace_prepare.rs"]
pub(crate) mod prepare;
#[path = "render_workspace_materials.rs"]
mod materials;
#[path = "render_workspace_setups.rs"]
mod setups;
#[path = "render_workspace_shot.rs"]
pub(crate) mod shot;
#[path = "render_workspace_shots.rs"]
pub(crate) mod shots;
#[path = "render_ui/scene.rs"]
pub(crate) mod scene;
#[path = "render_workspace_studio.rs"]
mod studio;
#[path = "render_workspace_transport.rs"]
mod transport;
#[path = "render_workspace_thumbnails.rs"]
mod thumbnails;
#[path = "render_ui/wear.rs"]
mod wear;
/// The browser's preview budget: WebGPU and WebGL share the tab's memory, so it stays small.
const WEB_GEOMETRY_BYTES: u64 = 128 * 1024 * 1024;
/// Desktop: at most this many of the device's largest buffers of geometry...
const DESKTOP_GEOMETRY_BUFFERS: u64 = 8;
/// ...and never more than this, whatever the device allows.
const DESKTOP_GEOMETRY_CEILING: u64 = 2 * 1024 * 1024 * 1024;
/// The product preview's geometry budget for a device whose largest buffer is `max_buffer_size`
/// bytes (`wgpu::Device::limits`, what the device was created with). Uploads are split into
/// buffers of at most that size, so the budget bounds memory, not a single buffer: 2 GiB on a
/// device with the standard 256 MiB buffers. An allocation the device still refuses is caught
/// by the upload's error scope and reported, not a crash.
pub(crate) fn geometry_budget(max_buffer_size: u64, web: bool) -> u64 {
if web { WEB_GEOMETRY_BYTES } else { max_buffer_size.saturating_mul(DESKTOP_GEOMETRY_BUFFERS).min(DESKTOP_GEOMETRY_CEILING) }
}
/// Apply the saved compatibility preference to the device-derived budget.
fn preferred_geometry_budget(device_budget: u64, previous: bool) -> u64 {
if previous { MAX_GEOMETRY_BYTES as u64 } else { device_budget }
}
fn admit_geometry(bytes: u64, budget: u64) -> Result<(), String> {
if bytes > budget {
return Err(format!(
"Render preview needs {:.1} MiB of geometry; the limit is {:.1} MiB. Hide bodies in Design, then return to Render and try again.",
bytes as f64 / 1048576.0,
budget as f64 / 1048576.0
));
}
Ok(())
}
/// The message when the device refused the preview's geometry.
fn upload_refusal(bytes: u64, error: &str) -> String {
format!(
"The graphics device could not hold the Render preview's {:.1} MiB of geometry ({error}). Hide bodies in Design, then return to Render and try again.",
bytes as f64 / 1048576.0
)
}
#[cfg(test)]
#[path = "render_workspace_tests.rs"]
mod tests;
type PathFactory = Box<dyn FnOnce() -> Result<ImageHost, String> + Send>;
pub struct State {
thumbnails: thumbnails::Cache,
pending_setup: Option<PathFactory>,
pub host: Option<ExecutorDescriptor>,
pub path_host: PathHost,
/// How long the last path tracer setup took, in seconds, per viewport adapter
/// ([`adapter_key`]); kept in the preferences to estimate the next one.
pub setup_seconds: std::collections::BTreeMap<String, f64>,
/// The viewport adapter the current setup runs on.
pub setup_key: Option<String>,
/// The file that says a setup is running ([`SETUP_MARKER`] in the settings folder); `None`:
/// nowhere to keep it (browser, tests), so a setup that crashes is simply run again.
#[cfg(not(target_arch = "wasm32"))]
setup_marker: Option<std::path::PathBuf>,
/// The adapter whose setup was still running when the app last stopped (#9236).
#[cfg(not(target_arch = "wasm32"))]
crashed_setup: Option<String>,
pub geometry_budget: u64,
/// A GPU error the preview's last geometry upload caught.
pub upload_error: crate::gpu::UploadError,
pub image_host: Option<solidcraft_engine::render::job::CpuHost>,
live: live::State,
displayed: displayed::State,
pub view: ViewState,
/// This frame's existing canvas response, consumed once after result chrome
/// publishes its real input shields. Never stored in document/tab state.
result_navigation: Option<(egui::Rect, egui::Response, bool)>,
revision: u64,
design_camera: Option<(Camera, bool)>,
entry_fit: Option<EntryFit>,
slot: SceneSlot,
key: Option<u64>,
/// What the product scene was extracted from: the document's and the world state's
/// addresses, a hash of what decides visibility and the geometry budget
/// ([`State::prepare_preview`]).
scene_signature: Option<(u64, usize, u64, u64)>,
/// The document and world state `scene_signature` names, held so their addresses cannot be
/// reused by others while the signature refers to them.
scene_sources: Option<(Arc<solidcraft_engine::doc::Document>, Arc<solidcraft_engine::doc::ModelState>)>,
scene: Option<ProductScene>,
scene_error: Option<String>,
preview_upload_bytes: Option<usize>,
image: Option<(solidcraft_engine::render::job::JobId, Result<egui::TextureHandle, String>)>,
image_info: Option<solidcraft_engine::render::job::FrameInfo>,
preview_image: Option<PreviewImage>,
clipboard_image: Option<egui::ColorImage>,
clipboard_text: Option<String>,
comparison_images: Vec<(solidcraft_engine::render::job::JobId, Result<egui::TextureHandle, String>)>,
}
/// Provisional pixels are never an export source and never replace the retained final image.
struct PreviewImage {
info: PreviewInfo,
image: Result<egui::TextureHandle, String>,
}
/// Only the automatic fit of an otherwise clean Render entry may move its transient
/// camera baseline. The saved shot camera remains owned by its explicit update action.
struct EntryFit {
name: String,
clean: RenderSetup,
source: Camera,
bounds: solidcraft_engine::geom::Aabb3,
interim: Camera,
layout: Option<crate::viewport_layout::Layout>,
}
struct DisplayImage<'a> {
info: &'a solidcraft_engine::render::job::FrameInfo,
image: &'a Result<egui::TextureHandle, String>,
preview: Option<&'a PreviewInfo>,
}
/// Application-wide setup, retained across document changes. The worker owns a
/// cloned adapter and initializes the job device; the UI receives the finished host.
#[derive(Default)]
pub enum PathHost {
#[default]
NotStarted,
/// The worker's answer, and when it started: shader compilation can take minutes.
Preparing(std::sync::mpsc::Receiver<Result<ImageHost, String>>, std::time::Instant),
Ready(ImageHost),
Failed(String),
}
impl PathHost {
/// Setup is a temporary readiness state, not a failed device or request.
fn pending_message_key(&self) -> Option<&'static str> {
match self {
Self::NotStarted => Some("render.gpu_path_not_started"),
Self::Preparing(..) => Some("render.gpu_path_preparing"),
Self::Ready(_) | Self::Failed(_) => None,
}
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn start(&mut self, create: impl FnOnce() -> Result<ImageHost, String> + Send + 'static) {
if !matches!(self, Self::NotStarted) {
return;
}
let (tx, rx) = std::sync::mpsc::channel();
// Dropping the handle detaches: neither startup nor shutdown joins a driver
// that may spend minutes compiling or warming up its pipelines.
*self = match std::thread::Builder::new().name("gpu-path-setup".into()).spawn(move || {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(create))
.unwrap_or_else(|_| Err(crate::i18n::tr("render.error_setup_panicked").into()));
let _ = tx.send(result);
}) {
Ok(_) => Self::Preparing(rx, std::time::Instant::now()),
Err(e) => Self::failed(crate::i18n::format("render.error_setup_worker", &[("error", &e.to_string())])),
};
}
fn failed(message: String) -> Self {
log::warn!("progressive render unavailable: {message}");
Self::Failed(message)
}
/// Take the worker's answer if it has come; returns how long a successful setup took.
fn poll(&mut self) -> Option<std::time::Duration> {
let Self::Preparing(rx, started) = self else {
return None;
};
let took = started.elapsed();
*self = match rx.try_recv() {
Ok(Ok(host)) => Self::Ready(host),
Ok(Err(error)) => Self::failed(error),
Err(std::sync::mpsc::TryRecvError::Empty) => return None,
Err(std::sync::mpsc::TryRecvError::Disconnected) => Self::failed(crate::i18n::tr("render.error_setup_stopped").into()),
};
matches!(self, Self::Ready(_)).then_some(took)
}
}
/// The samples slider's top end: 2^12 = 4096 samples per pixel.
#[cfg(test)]
const MAX_SAMPLES_EXPONENT: u32 = 12;
/// Setup times kept per adapter, at most.
const MAX_SETUP_TIMES: usize = 16;
/// The key [`State::setup_seconds`] files an adapter's setup time under: a driver update
/// usually empties the driver's shader cache, so the driver is part of it.
pub fn adapter_key(info: &egui_wgpu::wgpu::AdapterInfo) -> String {
format!("{} | {:?} | {} {}", info.name.trim(), info.backend, info.driver.trim(), info.driver_info.trim())
}
/// Remember how long the setup on `key` took, for the next start's estimate.
fn record_setup(state: &mut State, took: std::time::Duration) {
let Some(key) = state.setup_key.clone() else {
return;
};
if state.setup_seconds.len() >= MAX_SETUP_TIMES && !state.setup_seconds.contains_key(&key) {
return;
}
state.setup_seconds.insert(key, took.as_secs_f64());
}
/// Setup times from the preferences: finite, non-negative and at most a day each.
pub fn load_setup_seconds(value: &serde_json::Value) -> std::collections::BTreeMap<String, f64> {
value
.as_object()
.into_iter()
.flatten()
.filter_map(|(k, v)| Some((k.clone(), v.as_f64().filter(|s| s.is_finite() && (0.0..=86_400.0).contains(s))?)))
.take(MAX_SETUP_TIMES)
.collect()
}
/// Minutes and seconds, as `1:05`.
fn mmss(d: std::time::Duration) -> String {
let s = d.as_secs();
format!("{}:{:02}", s / 60, s % 60)
}
/// The path tracer's setup as it goes: a progress bar estimated from the last setup on this
/// adapter, else a spinner with the time so far. Drivers report no progress of their own.
fn setup_progress(ui: &mut egui::Ui, app: &SolveApp, started: std::time::Instant) {
let elapsed = started.elapsed();
let expected = app.render_workspace.setup_key.as_ref().and_then(|k| app.render_workspace.setup_seconds.get(k)).copied();
ui.label(app.tr("render.gpu_path_preparing"));
match expected.map(|s| std::time::Duration::from_secs_f64(s.max(1.0))) {
Some(expected) if elapsed < expected.mul_f64(1.5) => {
let fraction = (elapsed.as_secs_f32() / expected.as_secs_f32()).min(0.99);
crate::ui_kit::progress(ui, "gpu_path_setup", fraction);
ui.label(format!("{} / ~{}", mmss(elapsed), mmss(expected)));
// The bar moves with time, so keep drawing while it is shown.
ui.ctx().request_repaint_after(std::time::Duration::from_millis(250));
}
_ => {
ui.horizontal(|ui| {
ui.spinner();
ui.label(mmss(elapsed));
});
if expected.is_none() {
ui.small(app.tr("render.gpu_path_first_setup"));
}
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) enum Stage {
#[default]
Look,
Light,
Frame,
Output,
}
impl Stage {
pub(crate) const ALL: [Self; 4] = [Self::Look, Self::Light, Self::Frame, Self::Output];
pub(crate) fn key(self) -> &'static str {
match self {
Self::Look => "look",
Self::Light => "light",
Self::Frame => "frame",
Self::Output => "output",
}
}
pub(crate) fn label(self) -> &'static str {
match self {
Self::Look => "render.stage_look",
Self::Light => "render.stage_light",
Self::Frame => "render.stage_frame",
Self::Output => "render.stage_output",
}
}
}
/// Browser focus is transient per-document view state, never part of a saved design.
#[derive(Clone, Debug, Default, PartialEq)]
pub enum RenderSelection {
#[default]
Nothing,
Object(Vec<solidcraft_engine::Sel>),
Environment,
Wear,
Lighting,
/// Method/type/index identity until named light commands provide persistent IDs.
Light(String),
Shot(String),
Output,
Sampling,
Effects,
Check,
}
/// Focus a Render editor without changing the shared modelling selection.
pub(crate) fn selection_editor(app: &mut SolveApp, selection: &RenderSelection) {
app.render_workspace.view.selection = selection.clone();
app.render_workspace.view.inspector.hidden = false;
}
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.
#[derive(Clone, Debug)]
pub struct ViewState {
pub(crate) assign: assign::State,
pub(crate) frame: shot::Frame,
lights: light::View,
job_shot: Option<String>,
save_shot_name: Option<String>,
pub name: String,
pub selection: RenderSelection,
pub(crate) stage: Stage,
pub(crate) by_look: bool,
pub(crate) search_objects: bool,
pub(crate) object_query: String,
draft: RenderSetup,
dirty: bool,
live_paused: bool,
/// Product framing retained across Design/Render visits, never a saved setting.
render_camera: Option<Camera>,
/// The CPU sampling choice was initialised or explicitly selected in this draft.
cpu_sampling_initialized: bool,
clean_setup: Option<RenderSetup>,
/// Whether the clean baseline existed in the design, distinguishing Undo removal from
/// an unsaved initial choice that must survive preference or host changes.
clean_persisted: bool,
clean_name: String,
job: Option<solidcraft_engine::render::job::JobId>,
completed: Option<solidcraft_engine::render::job::JobId>,
retained: Vec<solidcraft_engine::render_jobs::RetainedResult>,
follow_job: bool,
/// Only a UI Render action that opened the viewer may automatically return to live.
auto_result_job: Option<AutoResultJob>,
compare: Option<compare::View>,
transparent: bool,
method: ImageMethod,
raytrace: RaytraceOptions,
samples: u32,
max_depth: u32,
seed: u32,
studio: studio::View,
materials: materials::View,
library: library::View,
inspector: inspector::View,
environment_ring: environment::RingView,
cpu: cpu::View,
overwrite: bool,
result: bool,
result_camera: Camera,
result_scale: ResultScale,
/// Full image domain and explicit scale policy last applied by the host.
/// Panel geometry is deliberately absent: moving chrome never reframes.
result_domain: Option<(egui::Rect, [u32; 2], f32, ResultScale)>,
result_job: Option<solidcraft_engine::render::job::JobId>,
}
/// The engine retains terminal failures as metadata only. Keep the submitted handle while
/// automatic viewing owns the result, including its native cleanup barrier.
#[derive(Clone)]
struct AutoResultJob {
job: solidcraft_engine::render::job::JobId,
handle: solidcraft_engine::render::job::JobHandle,
}
impl std::fmt::Debug for AutoResultJob {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Debug::fmt(&self.job, f)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
enum ResultScale {
#[default]
Fit,
Actual,
Free,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
enum ImageMethod {
#[default]
Raster,
CpuRaytrace,
GpuRaytrace,
}
impl ImageMethod {
fn label(self) -> &'static str {
match self {
Self::Raster => "render.method_raster",
Self::CpuRaytrace => "render.method_cpu",
Self::GpuRaytrace => "render.method_gpu",
}
}
}
impl Default for ViewState {
fn default() -> Self {
Self {
assign: assign::State::default(),
lights: Default::default(),
job_shot: None,
frame: Default::default(),
save_shot_name: None,
name: "Studio".into(),
selection: RenderSelection::Nothing,
stage: Stage::Look,
by_look: false,
search_objects: false,
object_query: String::new(),
draft: RenderSetup::default(),
dirty: false,
live_paused: false,
render_camera: None,
cpu_sampling_initialized: false,
clean_setup: None,
clean_persisted: false,
clean_name: "Studio".into(),
job: None,
completed: None,
retained: Vec::new(),
follow_job: true,
auto_result_job: None,
compare: None,
transparent: false,
method: ImageMethod::Raster,
raytrace: RaytraceOptions::default(),
samples: 64,
max_depth: 8,
seed: 0,
studio: studio::View::default(),
materials: materials::View::default(),
library: library::View::default(),
inspector: inspector::View::default(),
environment_ring: environment::RingView::default(),
cpu: cpu::View::default(),
overwrite: false,
result: false,
result_camera: Camera { yaw: 0.0, pitch: std::f64::consts::FRAC_PI_2, ..Default::default() },
result_scale: ResultScale::Fit,
result_domain: None,
result_job: None,
}
}
}
impl Default for State {
fn default() -> Self {
Self {
thumbnails: Default::default(),
host: None,
path_host: PathHost::default(),
pending_setup: None,
setup_seconds: Default::default(),
setup_key: None,
#[cfg(not(target_arch = "wasm32"))]
setup_marker: None,
#[cfg(not(target_arch = "wasm32"))]
crashed_setup: None,
geometry_budget: WEB_GEOMETRY_BYTES,
upload_error: Arc::new(Mutex::new(None)),
image_host: None,
live: Default::default(),
displayed: Default::default(),
view: Default::default(),
result_navigation: None,
revision: u64::MAX,
design_camera: None,
entry_fit: None,
slot: Arc::new(Mutex::new(None)),
key: None,
scene_signature: None,
scene_sources: None,
scene: None,
scene_error: None,
preview_upload_bytes: None,
image: None,
image_info: None,
preview_image: None,
clipboard_image: None,
clipboard_text: None,
comparison_images: Vec::new(),
}
}
}
impl State {
/// Retain the selected viewport adapter, but do not open another device or
/// compile shaders until the GPU path image method is used in Render
/// ([`wants_path_host`]). A later viewport installation (for example safe-mode
/// fallback) replaces only a not-yet-started factory.
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn defer_path_host(&mut self, key: String, create: impl FnOnce() -> Result<ImageHost, String> + Send + 'static) {
if matches!(self.path_host, PathHost::NotStarted) {
self.setup_key = Some(key);
self.pending_setup = Some(Box::new(create));
}
}
/// Keep the running-setup marker at `path`, and read what the last launch left there: a
/// marker still present means the app stopped during that setup. Once per launch.
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn watch_setup(&mut self, path: Option<std::path::PathBuf>) {
if self.setup_marker.is_some() {
return;
}
self.crashed_setup = path.as_deref().and_then(marker_adapter);
if let Some(key) = &self.crashed_setup {
log::warn!("the last GPU path tracer setup on {key} did not finish: the app stopped during it");
}
self.setup_marker = path;
}
/// Whether the deferred setup waits for the user because it stopped the app last time.
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn setup_crashed(&self) -> bool {
self.crashed_setup.is_some() && self.crashed_setup == self.setup_key && self.pending_setup.is_some()
}
#[cfg(not(target_arch = "wasm32"))]
fn start_deferred_path_host(&mut self) {
if !matches!(self.path_host, PathHost::NotStarted) || self.pending_setup.is_none() {
return;
}
// A driver that takes the process down while it compiles (#9236) is beyond any error
// scope or unwind guard; the marker is how the next launch learns of it.
if self.setup_crashed() {
self.path_host = PathHost::failed(crate::i18n::tr("render.gpu_path_crashed").into());
return;
}
let Some(create) = self.pending_setup.take() else {
return;
};
if let (Some(path), Some(key)) = (&self.setup_marker, &self.setup_key) {
write_marker(path, key);
}
self.path_host.start(create);
if !matches!(self.path_host, PathHost::Preparing(..)) {
self.clear_setup_marker();
}
}
/// Run a setup that stopped the app last time again, at the user's request.
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn retry_crashed_setup(&mut self) {
if self.setup_crashed() && matches!(self.path_host, PathHost::Failed(_)) {
self.crashed_setup = None;
self.path_host = PathHost::NotStarted;
self.start_deferred_path_host();
}
}
/// Take the worker's answer if it has come: either answer means the process survived it.
fn poll_setup(&mut self) -> Option<std::time::Duration> {
let preparing = matches!(self.path_host, PathHost::Preparing(..));
let took = self.path_host.poll();
if preparing && !matches!(self.path_host, PathHost::Preparing(..)) {
self.clear_setup_marker();
}
took
}
#[cfg(target_arch = "wasm32")]
fn clear_setup_marker(&self) {}
#[cfg(not(target_arch = "wasm32"))]
fn clear_setup_marker(&self) {
if let Some(path) = &self.setup_marker
&& let Err(e) = std::fs::remove_file(path)
&& e.kind() != std::io::ErrorKind::NotFound
{
log::warn!("could not remove {}: {e}", path.display());
}
}
}
/// The marker file a running path tracer setup keeps in the settings folder.
pub const SETUP_MARKER: &str = "gpu-path-setup.json";
/// A marker is a few dozen bytes; anything longer is not one.
#[cfg(not(target_arch = "wasm32"))]
const MAX_MARKER_BYTES: u64 = 64 * 1024;
/// The adapter a marker names, if `path` holds a readable one.
#[cfg(not(target_arch = "wasm32"))]
fn marker_adapter(path: &std::path::Path) -> Option<String> {
use std::io::Read;
let mut text = String::new();
std::fs::File::open(path).ok()?.take(MAX_MARKER_BYTES + 1).read_to_string(&mut text).ok()?;
if text.len() as u64 > MAX_MARKER_BYTES {
return None;
}
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
value.get("adapter")?.as_str().filter(|key| !key.is_empty()).map(str::to_owned)
}
#[cfg(not(target_arch = "wasm32"))]
fn write_marker(path: &std::path::Path, key: &str) {
if let Some(dir) = path.parent()
&& let Err(e) = std::fs::create_dir_all(dir)
{
log::warn!("could not create {}: {e}", dir.display());
}
if let Err(e) = std::fs::write(path, json!({"adapter": key}).to_string()) {
log::warn!("could not write {}: {e}", path.display());
}
}
/// Under the failure message: when the setup stopped the app last time (#9236), the button
/// that runs it again. Nothing else runs it.
pub(crate) fn retry_crashed_setup(app: &mut SolveApp, ui: &mut egui::Ui) {
#[cfg(not(target_arch = "wasm32"))]
if app.render_workspace.setup_crashed() {
let response = crate::ui_kit::button(ui, app.tr("render.gpu_path_retry"), crate::ui_kit::Button::Normal);
crate::scenario::publish_target("render:gpu-path-retry", response.rect);
if response.clicked() {
app.render_workspace.retry_crashed_setup();
}
}
#[cfg(target_arch = "wasm32")]
let _ = (app, ui);
}
/// The app is closing normally: a setup still running did not stop it.
pub fn close(app: &mut SolveApp) {
if matches!(app.render_workspace.path_host, PathHost::Preparing(..)) {
app.render_workspace.clear_setup_marker();
}
}
pub fn active(app: &SolveApp) -> bool {
crate::workspace::render_tab(&app.ui.tab)
}
pub(crate) fn result_active(app: &SolveApp) -> bool {
active(app) && app.render_workspace.view.result
}
pub(crate) fn comparison_active(app: &SolveApp) -> bool {
active(app) && app.render_workspace.view.compare.is_some()
}
pub(crate) fn comparison_drag_captured(app: &SolveApp) -> bool {
active(app) && app.render_workspace.view.compare.as_ref().is_some_and(|view| view.dragging)
}
pub(crate) fn fit_result(app: &mut SolveApp) {
app.render_workspace.view.result_scale = ResultScale::Fit;
app.render_workspace.view.result_domain = None;
}
/// Read-only identities for automation and diagnostics. Does not prepare a
/// request, open a device, evaluate geometry, change the selected result or pump
/// a job. Clients must use render.status for the exact identity returned here.
pub(crate) fn inspect_state(app: &SolveApp) -> serde_json::Value {
let view = &app.render_workspace.view;
let method = match view.method {
ImageMethod::Raster => "raster",
ImageMethod::CpuRaytrace => "cpu_raytrace",
ImageMethod::GpuRaytrace => "gpu_path",
};
json!({
"active": active(app), "stage": view.stage.key(), "setup": view.name, "draft_dirty": view.dirty,
"method": method, "job": view.job, "completed": view.completed,
"results": view.retained,
"displayed_receipt": displayed::inspect(app),
"comparison": view.compare,
"live": live::inspect(app), "preparation": prepare::inspect(app), "batch_preparation": prepare::inspect_batches(app),
"queue": app.session.render_queue_state(),
"showing_result": view.result, "export_format": if view.studio.export_exr {"exr"} else {"png"},
})
}
pub fn host_executor(max_dimension: u32, depth: bool, samples: u32) -> Result<ExecutorDescriptor, String> {
if !matches!(samples, 1 | 2 | 4 | 8 | 16) {
return Err(crate::i18n::tr("render.error_gpu_samples").into());
}
Ok(ExecutorDescriptor {
id: ExecutorId::new("gpu-viewport").map_err(|e| e.to_string())?,
availability: if depth && max_dimension > 0 {
Availability::Available
} else {
Availability::Unavailable { reason: crate::i18n::tr("render.error_preview_device").into() }
},
profiles: vec![RenderProfile {
mode: RenderMode::Preview,
operation: RenderOperation::Viewport,
formats: Vec::new(),
features: vec![solidcraft_engine::render::RenderFeature::Pbr],
}],
limits: RenderLimits { max_dimension: u64::from(max_dimension.clamp(1, 4096)), ..Default::default() },
scratch: ScratchLayout {
sample_scale: 1,
sample_bytes_per_pixel: 8 * u64::from(samples),
output_bytes_per_pixel: 8,
encoding_bytes_per_pixel: 0,
},
})
}
/// Whether the GPU path tracer is wanted now: Render is open with the GPU path image method.
/// Its setup compiles a large shader that some Vulkan drivers take gigabytes and minutes over,
/// so Render with the Raster or CPU method never starts it (#9041).
#[cfg(not(target_arch = "wasm32"))]
fn wants_path_host(app: &SolveApp) -> bool {
active(app) && app.render_workspace.view.method == ImageMethod::GpuRaytrace
}
pub fn sync_backend(app: &mut SolveApp) {
#[cfg(not(target_arch = "wasm32"))]
if wants_path_host(app) {
app.render_workspace.start_deferred_path_host();
}
if let Some(took) = app.render_workspace.poll_setup() {
record_setup(&mut app.render_workspace, took);
}
if let PathHost::Ready(host) = &app.render_workspace.path_host
&& let Err(e) = app.session.register_render_job_host(host.clone())
{
app.render_workspace.path_host = PathHost::failed(e.to_string());
app.set_status(e.to_string(), true);
}
if app.session.render_job_host().is_none()
&& let Some(host) = &app.render_workspace.image_host
&& let Err(e) = app.session.set_render_job_host(Some(host.clone()))
{
app.set_status(e.to_string(), true);
}
if app.session.render_viewport() == app.render_workspace.host.as_ref() {
return;
}
if let Err(e) = app.session.set_render_viewport(app.render_workspace.host.clone()) {
app.set_status(e.to_string(), true);
}
}
/// Cooperative work belongs to the frame loop, never to a status/control request. Keep
/// scheduling frames even after leaving Render so a browser job can finish in Design.
pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {
library::poll_import(app, ctx);
if !app.universal_panel_host_enabled() {
// Classic shell input and Fit run before the host overlay finalizer.
crate::shell::register_panel(app, "render:result-controls", None, None);
}
if let Some(text) = app.render_workspace.clipboard_text.take() {
ctx.copy_text(text);
}
if let Some(image) = app.render_workspace.clipboard_image.take() {
ctx.copy_image(image);
}
if matches!(app.render_workspace.path_host, PathHost::Preparing(..)) {
// Poll even in Design or an idle window, without continuously redrawing.
ctx.request_repaint_after(std::time::Duration::from_millis(100));
}
if let Some(host) = &app.render_workspace.image_host {
match host.pump(1024) {
Ok(true) => ctx.request_repaint(),
Ok(false) => {}
Err(e) => app.set_status(e.to_string(), true),
}
}
crate::documents::advance_render_batches(app, ctx);
if let Err(error) = app.session.advance_render_batch() {
app.set_status(error.to_string(), true);
}
follow_batch(app);
let queue = app.session.render_queue_state();
if queue.running != 0 || queue.waiting != 0 {
ctx.request_repaint_after(std::time::Duration::from_millis(100));
}
if app.render_workspace.view.job.is_some() {
cache_render_images(app, ctx);
}
prepare::tick(app, ctx);
live::tick(app, ctx);
}
pub fn reset_document(app: &mut SolveApp) {
// The app-global preparation owner drains across this document replacement.
prepare::cancel(app);
crate::render_ui::reset_shell(app);
app.ui.ribbon_context = None;
let host = app.render_workspace.host.clone();
let image_host = app.render_workspace.image_host.clone();
let geometry_budget = app.render_workspace.geometry_budget;
let path_host = std::mem::take(&mut app.render_workspace.path_host);
let setup_seconds = std::mem::take(&mut app.render_workspace.setup_seconds);
let setup_key = app.render_workspace.setup_key.take();
let pending_setup = app.render_workspace.pending_setup.take();
#[cfg(not(target_arch = "wasm32"))]
let (setup_marker, crashed_setup) = (app.render_workspace.setup_marker.take(), app.render_workspace.crashed_setup.take());
// Hosts are shared across documents. Keep late scratch captures and their cleanup
// barrier until released so a new document cannot race an old live job for admission.
let mut live = std::mem::take(&mut app.render_workspace.live);
live.retire_document();
app.render_workspace =
State { host, image_host, path_host, setup_seconds, setup_key, pending_setup, geometry_budget, live, ..Default::default() };
#[cfg(not(target_arch = "wasm32"))]
{
// The running-setup marker is the application's, like the setup itself.
app.render_workspace.setup_marker = setup_marker;
app.render_workspace.crashed_setup = crashed_setup;
}
if active(app) {
app.ui.tab = "MODEL".into();
}
sync_backend(app);
}
pub(crate) fn invalidate_images(app: &mut SolveApp) {
app.render_workspace.displayed.clear();
app.render_workspace.image = None;
app.render_workspace.image_info = None;
app.render_workspace.preview_image = None;
app.render_workspace.comparison_images.clear();
}
pub fn invalidate_scene(app: &mut SolveApp) {
app.render_workspace.thumbnails = Default::default();
app.render_workspace.revision = u64::MAX;
app.render_workspace.scene_signature = None;
app.render_workspace.scene_sources = None;
app.render_workspace.scene = None;
app.render_workspace.scene_error = None;
app.render_workspace.preview_upload_bytes = None;
app.render_workspace.key = None;
if let Ok(mut slot) = app.render_workspace.slot.lock() {
*slot = None;
}
}
pub fn enter(app: &mut SolveApp, render: bool) -> Result<(), String> {
if render {
if app.session.active_sketch.is_some() || app.tool.is_some() || app.dialog.is_some() || app.file_load.busy() {
return Err(crate::i18n::tr("render.error_finish_operation").into());
}
app.run("render.scene", json!({}))?;
let entering = !active(app);
if entering {
app.render_workspace.displayed.clear();
app.render_workspace.design_camera = Some((app.cam, app.ui.perspective));
app.ui.tab = "RENDER".into();
select_stage(app, app.render_workspace.view.stage.key());
if app.render_workspace.view.selection == RenderSelection::Nothing {
selection_editor(app, &RenderSelection::Nothing);
}
}
let remembered =
entering.then_some(app.render_workspace.view.render_camera).flatten().filter(|_| !app.preferences.render_legacy_image_defaults);
if let Some(camera) = remembered {
app.run("render.camera.set", json!({"camera":camera}))?;
app.follow_view_request(false);
app.ui.perspective = camera.fov > 0.0;
}
setups::refresh_dirty(app);
let hydrate_camera = entering
&& remembered.is_none()
&& !app.preferences.render_legacy_image_defaults
&& !app.render_workspace.view.dirty
&& !setups::has_runtime_inputs(app);
setups::sync_revision(app);
let mut restored = remembered.is_some();
if hydrate_camera && app.session.doc.render.setups.get(&app.render_workspace.view.name).is_some_and(|setup| setup.camera != Camera::default())
{
let name = app.render_workspace.view.name.clone();
inspector::activate_saved_shot(app, name)?;
restored = true;
}
// Only an uncomposed first view fits automatically. An explicit saved or
// remembered Render camera keeps its lens projection and exact framing.
if entering && !restored {
let scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|e| e.to_string())?;
if !scene.bounds.is_empty() {
let clean =
app.render_workspace.view.clean_setup.clone().filter(|clean| {
!app.render_workspace.view.dirty && !setups::has_runtime_inputs(app) && setups::draft(app).as_ref() == Ok(clean)
});
let source = app.cam;
app.fit_bounds(scene.bounds);
app.render_workspace.entry_fit = clean.map(|clean| EntryFit {
name: app.render_workspace.view.name.clone(),
clean,
source,
bounds: scene.bounds,
interim: app.cam,
layout: None,
});
}
}
#[cfg(not(target_arch = "wasm32"))]
if wants_path_host(app) {
app.render_workspace.start_deferred_path_host();
}
} else {
app.render_workspace.displayed.clear();
assign::stop(app);
if active(app) {
app.render_workspace.view.render_camera = (!app.preferences.render_legacy_image_defaults).then_some(app.cam);
setups::refresh_dirty(app);
}
if let Some((camera, perspective)) = app.render_workspace.design_camera.take() {
app.cam = camera;
app.ui.up_axis = camera.up;
app.ui.perspective = perspective;
}
app.ui.tab = "MODEL".into();
crate::render_ui::reset_shell(app);
}
app.viewport.hover = None;
app.cam_anim = None;
if !render {
cancel_entry_fit(app);
app.pending_fit = None;
}
Ok(())
}
/// Camera takeover cancels the entry-only allowance along with the pending fit.
pub(crate) fn cancel_entry_fit(app: &mut SolveApp) {
app.render_workspace.entry_fit = None;
}
/// The first Render frame can still carry Design's measured floating-panel bounds.
/// Only this exact automatic entry fit waits for two matching Render measurements.
pub(crate) fn wait_entry_fit_layout(app: &mut SolveApp) -> bool {
let Some(entry) = app.render_workspace.entry_fit.as_ref() else {
return false;
};
if !active(app)
|| app.render_workspace.view.name != entry.name
|| app.cam != entry.interim
|| app.pending_fit != Some((entry.source, entry.bounds, false, false))
{
cancel_entry_fit(app);
return false;
}
let Some(layout) = app.viewport.layout.as_ref() else {
return false;
};
let layout = picture_layout(app, layout);
let Some(entry) = app.render_workspace.entry_fit.as_mut() else {
return false;
};
if entry.layout.as_ref() == Some(&layout) {
return false;
}
entry.layout = Some(layout);
true
}
/// Called only when a nonanimated pending fit actually installs its final camera.
pub(crate) fn settle_entry_fit(app: &mut SolveApp, source: Camera, bounds: solidcraft_engine::geom::Aabb3, previous: Camera) {
let Some(entry) = app.render_workspace.entry_fit.take() else {
return;
};
if !active(app)
|| app.render_workspace.view.name != entry.name
|| source != entry.source
|| bounds != entry.bounds
|| previous != entry.interim
|| app.render_workspace.view.clean_setup.as_ref() != Some(&entry.clean)
|| setups::has_runtime_inputs(app)
{
return;
}
let Ok(mut draft) = setups::draft(app) else {
return;
};
draft.camera = entry.clean.camera;
if draft != entry.clean {
return;
}
let Some(clean) = app.render_workspace.view.clean_setup.as_mut() else {
return;
};
clean.camera = app.cam;
setups::refresh_dirty(app);
}
/// Stage navigation is transient per-document state. It never applies a resource or starts a job.
pub(crate) fn select_stage(app: &mut SolveApp, key: &str) {
let stage = match key {
"look" => Stage::Look,
"light" => Stage::Light,
"frame" => Stage::Frame,
"output" => Stage::Output,
_ => return,
};
app.render_workspace.view.stage = stage;
app.render_workspace.view.inspector.hidden = false;
let sections: &[&str] = match stage {
Stage::Look => &["objects"],
Stage::Light => &["lights", "environment"],
Stage::Frame => &["shots"],
Stage::Output => &[],
};
for section in sections {
app.tree.collapsed.remove(&format!("render:tree:{section}"));
}
if stage == Stage::Look {
app.tree.collapsed.remove("c0");
app.tree.collapsed.remove("c0/bodies");
// The Bodies folder starts closed while the Browser's rows do (Preferences › Layout).
app.tree.expanded.insert("c0/bodies".into());
}
}
pub(crate) fn switch_shot(app: &mut SolveApp, name: String) {
inspector::switch_shot(app, name);
}
pub(crate) fn stage_projection(app: &mut SolveApp, perspective: bool) -> Result<(), String> {
let mut camera = app.cam;
camera.fov = if perspective { 0.6 } else { 0.0 };
inspector::apply_camera_draft(app, camera)
}
pub(crate) fn output_summary(app: &SolveApp) -> (String, &'static str) {
let view = &app.render_workspace.view;
(format!("{} × {}", view.draft.width, view.draft.height), if view.studio.export_exr { "EXR" } else { "PNG" })
}
pub(crate) fn output_child_summary(app: &SolveApp, kind: &str) -> String {
let view = &app.render_workspace.view;
match kind {
"sampling" => format!(
"{} · {} spp",
app.tr("render.quality_custom"),
if view.method == ImageMethod::GpuRaytrace {
view.samples
} else {
view.raytrace.progressive.map_or(u32::from(view.raytrace.primary_samples), |p| p.samples_per_pixel)
}
),
"effects" => crate::i18n::format(
"render.children.look_summary",
&[
("tone", if view.studio.tone_map == solidcraft_engine::render::job::ToneMap::AcesFitted { "ACES" } else { "Reinhard" }),
("count", &view.studio.finishing.looks.len().to_string()),
],
),
"check" => inspector::check_summary(app),
_ => String::new(),
}
}
pub(crate) fn job_busy(app: &SolveApp) -> bool {
ribbon::busy(app)
}
pub(crate) fn output_stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {
inspector::stage_tools(app, ui);
}
pub(crate) fn job_ready(app: &SolveApp, id: &str) -> Result<(), String> {
ribbon::action_ready(app, id)
}
pub(crate) fn set_inspector_visible(app: &mut SolveApp, visible: bool) {
app.render_workspace.view.inspector.hidden = !visible;
}
pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
if crate::render_ui::focused(app) {
return;
}
inspector_panel::panel(app, ui);
}
/// Interactive stage-panel review. Direct engine JSON calls remain dialog-free.
/// S5 supplies its selected specification id without owning another consent form.
pub(crate) fn review_resource(app: &mut SolveApp, command: &str, id: &str) -> Result<(), String> {
match command {
"render.quality.prepare" => library::review::quality(app, id),
_ => Err("this command has no stage-panel review adapter".into()),
}
}
pub(crate) fn apply_browser_controls(app: &mut SolveApp, value: &serde_json::Value) {
let view = &mut app.render_workspace.view;
if let Some(by_look) = value.get("by_look").and_then(serde_json::Value::as_bool) {
view.by_look = by_look;
}
if let Some(search) = value.get("search").and_then(serde_json::Value::as_bool) {
view.search_objects = search;
}
if let Some(query) = value.get("query").and_then(serde_json::Value::as_str) {
view.object_query = query.into();
}
}
/// Local Browser-card content, never a new workspace or an alternative model tree.
pub(crate) fn browser_mode(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
if !active(app) {
return false;
}
if app.render_workspace.view.search_objects {
let mut query = app.render_workspace.view.object_query.clone();
crate::ui_kit::scope(ui, |ui| {
if crate::ui_kit::search_field(ui, ui.scope_id().with("render:tree:query"), &mut query, crate::i18n::tr("render.tree_search")).changed() {
let _ = app.run("view.render_browser", json!({"query":query}));
}
});
}
false
}
/// Per-stage companion sharing the Browser's dock policy.
pub(crate) fn appearances_card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) {
library::card(app, ui, bounds);
}
fn image_host(app: &SolveApp, method: ImageMethod) -> Result<&ImageHost, String> {
if method == ImageMethod::GpuRaytrace {
let host = match &app.render_workspace.path_host {
PathHost::NotStarted => return Err(app.tr("render.gpu_path_not_started").to_string()),
PathHost::Preparing(..) => return Err(app.tr("render.gpu_path_preparing").to_string()),
PathHost::Failed(error) => {
return Err(format!("{}: {error}", app.tr("render.gpu_path_failed")));
}
PathHost::Ready(host) => host,
};
let descriptor = host.descriptor().map_err(|error| error.to_string())?;
if !host.is_available()
|| !descriptor.profiles.iter().any(|profile| profile.features.contains(&solidcraft_engine::render::RenderFeature::Progressive))
{
return Err(app.tr("render.gpu_unavailable").to_string());
}
return Ok(host);
}
let host = app.session.render_job_host().ok_or_else(|| app.tr("render.image_host_missing").to_string())?;
host.validate_integrator(if method == ImageMethod::CpuRaytrace { Integrator::Raytrace } else { Integrator::Raster })
.map_err(|error| error.to_string())?;
Ok(host)
}
/// Check and Start use exactly this request, rebuilt at each click. The result camera is
/// temporarily installed only inside shared navigation; app.cam remains the product camera.
fn image_params(app: &SolveApp) -> Result<serde_json::Value, String> {
let view = &app.render_workspace.view;
image_host(app, view.method)?;
if app.session.model.is_stale() {
return Err(app.tr("render.image_scene_stale").to_string());
}
image_request(app)
}
/// Pure request construction is shared with offline setup editing; host checks stay above.
fn image_request(app: &SolveApp) -> Result<serde_json::Value, String> {
light::filter_request(app, raw_image_request(app)?)
}
fn raw_image_request(app: &SolveApp) -> Result<serde_json::Value, String> {
cpu::validate_progressive_image(app)?;
if !setups::requires_runtime_request(app) {
return Ok(json!({"settings":setups::image_snapshot(app)?}));
}
let view = &app.render_workspace.view;
// Temporary bindings and unsaved HDR captures use the runtime API. Embedded HDRs
// still resolve by their document resource ID when a temporary binding is present.
if !view.draft.surfaces.is_empty() {
return Err(app.tr("render.saved_maps_runtime_conflict").to_string());
}
let mut settings = RenderSetup { camera: app.cam, job: None, ..view.draft.clone() };
materials::overlay_coats(app, &mut settings)?;
let mut params = json!({"settings":settings,"transparent_background":view.transparent});
match view.method {
ImageMethod::Raster => {}
ImageMethod::CpuRaytrace => {
cpu::params(app, &mut params)?;
params["aging"] = json!(view.studio.aging);
}
ImageMethod::GpuRaytrace => {
params["progressive"] = json!(true);
params["samples"] = json!(view.samples);
params["max_depth"] = json!(view.max_depth);
params["seed"] = json!(view.seed);
studio::params(app, &mut params)?;
}
}
materials::params(app, &mut params)?;
Ok(params)
}
fn celestial_switch_active(app: &SolveApp) -> bool {
let view = &app.render_workspace.view;
view.studio.sun_enabled
|| match view.method {
ImageMethod::CpuRaytrace => view.cpu.environment == cpu::Environment::Sky,
ImageMethod::GpuRaytrace => view.studio.environment == studio::Environment::Sky,
ImageMethod::Raster => false,
}
}
/// One prospective numerical command transfers every shared physical effect.
/// Failure restores the full draft; navigation and saved camera stay untouched.
fn switch_celestial_method(app: &mut SolveApp, method: ImageMethod, enable_indirect: bool) -> Result<(), String> {
if setups::has_unportable_bindings(app) {
return Err(app.tr("render.setup_runtime_unsupported").into());
}
let before = setups::draft(app)?;
let before_render = std::sync::Arc::downgrade(&app.session.doc.render);
let previous = app.render_workspace.view.clone();
if previous.studio.transmission_samples != 1 {
return Err(app.tr("render.cpu_celestial_unportable").into());
}
let mut next = previous.clone();
if method == ImageMethod::CpuRaytrace {
if enable_indirect {
let depth = u8::try_from(next.max_depth).map_err(|_| app.tr("render.cpu_celestial_switch").to_string())?;
let path = solidcraft_engine::render::job::CpuPathOptions { max_depth: depth };
path.validate().map_err(|error| error.to_string())?;
next.raytrace.path = Some(path);
next.raytrace.progressive.get_or_insert_default();
next.raytrace.primary_samples = 1;
next.raytrace.shadows = true;
next.cpu_sampling_initialized = true;
}
if next.raytrace.path.is_none() {
if next.studio.volume.is_some_and(|volume| volume.active()) {
return Err(app.tr("render.cpu_volume_path_required").into());
}
if next.studio.caustics.is_some() {
return Err(app.tr("render.caustics_path_required").into());
}
if celestial_switch_active(app) {
return Err(app.tr("render.cpu_celestial_switch").into());
}
}
next.cpu.environment = match previous.studio.environment {
studio::Environment::Sky => cpu::Environment::Sky,
studio::Environment::Hdr => cpu::Environment::Hdr,
studio::Environment::None => {
let ambient = if previous.studio.lighting_enabled { previous.studio.ambient } else { [0.0; 3] };
let intensity = ambient.into_iter().fold(0.0_f64, f64::max);
if intensity > 64.0 {
return Err(app.tr("render.cpu_environment_bounds").into());
}
next.cpu.color = if intensity > 0.0 { ambient.map(|value| value / intensity) } else { [1.0; 3] };
next.cpu.intensity = intensity;
if intensity > 0.0 { cpu::Environment::Constant } else { cpu::Environment::None }
}
};
if previous.studio.environment != studio::Environment::None {
if previous.studio.environment == studio::Environment::Hdr && previous.studio.assume_linear_srgb {
return Err(app.tr("render.environment.primaries_gpu").into());
}
next.cpu.gradient = previous.studio.gradient;
next.cpu.rotation_rad = previous.studio.rotation_rad;
next.cpu.intensity = previous.studio.intensity;
next.cpu.hdr = previous.studio.hdr.clone();
}
} else if method == ImageMethod::GpuRaytrace {
next.studio.environment = match previous.cpu.environment {
cpu::Environment::Sky => studio::Environment::Sky,
cpu::Environment::Hdr => studio::Environment::Hdr,
cpu::Environment::None | cpu::Environment::Constant => studio::Environment::None,
};
next.studio.ambient = if previous.cpu.environment == cpu::Environment::Constant {
previous.cpu.color.map(|value| value * previous.cpu.intensity)
} else {
[0.0; 3]
};
if previous.cpu.environment != cpu::Environment::None && previous.cpu.environment != cpu::Environment::Constant {
next.studio.gradient = previous.cpu.gradient;
next.studio.rotation_rad = previous.cpu.rotation_rad;
next.studio.intensity = previous.cpu.intensity;
next.studio.hdr = previous.cpu.hdr.clone();
next.studio.assume_linear_srgb = false;
}
} else {
return Err(app.tr("render.output_raytrace_only").into());
}
light::celestial_method(app, &mut next, method)?;
next.method = method;
next.dirty = true;
app.render_workspace.view = next;
let result = environment::validate_atmosphere(app)
.and_then(|()| setups::snapshot(app).map(|_| ()))
.and_then(|()| cpu::validate_progressive_image(app))
.and_then(|()| setups::persist_editor(app, &before));
if let Err(error) = result {
app.render_workspace.view = previous;
return Err(error);
}
light::celestial_method_applied(app, &before_render, previous.method);
Ok(())
}
/// Volume and celestial choices share one atomic transaction, including both.
fn switch_volume_method(app: &mut SolveApp, method: ImageMethod, enable_indirect: bool) -> Result<(), String> {
switch_celestial_method(app, method, enable_indirect)
}
fn select_image_method(app: &mut SolveApp, method: ImageMethod) {
if method != app.render_workspace.view.method
&& method != ImageMethod::Raster
&& app.render_workspace.view.method != ImageMethod::Raster
&& (celestial_switch_active(app) || app.render_workspace.view.studio.volume.is_some() || app.render_workspace.view.studio.caustics.is_some())
{
let result = if app.render_workspace.view.studio.volume.is_some() {
switch_volume_method(app, method, false)
} else {
switch_celestial_method(app, method, false)
};
if let Err(error) = result {
app.set_status(error, true);
}
return;
}
app.render_workspace.view.method = method;
if method == ImageMethod::CpuRaytrace && !app.render_workspace.view.cpu_sampling_initialized {
let options = &mut app.render_workspace.view.raytrace;
if !app.preferences.render_legacy_image_defaults && options.progressive.is_none() {
options.progressive = Some(Default::default());
options.primary_samples = 1;
}
app.render_workspace.view.cpu_sampling_initialized = true;
}
// Raster has no exposure control. Selecting it explicitly selects its zero-EV response.
if method == ImageMethod::Raster {
app.render_workspace.view.draft.exposure_ev = 0.0;
}
app.render_workspace.view.dirty = true;
}
#[cfg(test)]
fn method_selector(app: &mut SolveApp, ui: &mut egui::Ui) {
ui.label(app.tr("render.image_method"));
method_dropdown(app, ui);
if image_host(app, app.render_workspace.view.method).is_err() {
crate::ui_kit::text(ui, app.tr("render.setup_offline_help"), crate::ui_kit::Text::Note("render.setup_offline_help"));
}
if app.render_workspace.view.method != ImageMethod::Raster {
crate::ui_kit::text(ui, app.tr("render.preview_image_settings_help"), crate::ui_kit::Text::Note("render.preview_image_settings_help"));
}
}
/// The same method authority in an aligned editor row or the legacy master form.
fn method_dropdown(app: &mut SolveApp, ui: &mut egui::Ui) -> egui::Response {
let current = app.render_workspace.view.method;
let label = app.tr(current.label()).to_string();
let bounded =
celestial_switch_active(app) || app.render_workspace.view.studio.volume.is_some() || app.render_workspace.view.studio.caustics.is_some();
let width = ui.available_width().min(crate::theme::Tokens::get().form_card_width);
let choices = |ui: &mut egui::Ui| {
for (method, handle) in [
(ImageMethod::Raster, "render:method-raster"),
(ImageMethod::CpuRaytrace, "render:method-cpu"),
(ImageMethod::GpuRaytrace, "render:method-gpu"),
] {
let capability = image_host(app, method).map(|_| ());
let label = app.tr(method.label()).to_string();
let response = crate::ui_kit::list_picker(ui, handle, &label, method == current);
crate::scenario::publish_handle(handle, response.rect.center());
if response.clicked() {
select_image_method(app, method);
ui.close();
}
if let Err(reason) = capability {
response.backing_on_hover_text(reason);
}
}
let volume_path = app.render_workspace.view.studio.volume.is_some_and(|volume| volume.active());
if current == ImageMethod::GpuRaytrace
&& (celestial_switch_active(app) || volume_path || app.render_workspace.view.studio.caustics.is_some())
&& app.render_workspace.view.raytrace.path.is_none()
{
let sampling = app.render_workspace.view.raytrace.progressive.unwrap_or_default();
let detail = crate::i18n::format(
if volume_path { "render.cpu_volume_enable_path_plan" } else { "render.cpu_celestial_adopt" },
&[
("depth", &app.render_workspace.view.max_depth.to_string()),
("spp", &sampling.samples_per_pixel.to_string()),
("seed", &sampling.seed.to_string()),
],
);
let short = app.tr(if volume_path { "render.cpu_volume_method_adopt" } else { "render.cpu_celestial_adopt_label" }).to_string();
let action = crate::ui_kit::list_picker(ui, "render:method-cpu-indirect", &short, false).on_hover_text(detail);
crate::scenario::publish_handle("render:method-cpu-indirect", action.rect.center());
if volume_path {
crate::scenario::publish_handle("render:method-cpu-volume", action.rect.center());
}
if action.clicked() {
if let Err(error) = switch_celestial_method(app, ImageMethod::CpuRaytrace, true) {
app.set_status(error, true);
}
ui.close();
}
}
};
let response = if bounded {
crate::ui_kit::bounded_dropdown_menu(ui, "render_image_method", &label, width, choices)
} else {
crate::ui_kit::dropdown_menu(ui, "render_image_method", &label, choices)
};
crate::scenario::publish_handle("render:method", response.rect.center());
response
}
fn cpu_sampling_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let progressive = cpu::progressive_controls(app, ui);
if progressive {
crate::ui_kit::text(ui, app.tr("render.cpu_progressive_help"), crate::ui_kit::Text::Note("render.cpu_progressive_help"));
}
if progressive && !app.preferences.render_legacy_image_defaults {
return;
}
ui.add_enabled_ui(!progressive, |ui| {
crate::ui_kit::text(ui, app.tr("render.children.edge_samples"), crate::ui_kit::Text::Inline);
let samples = app.render_workspace.view.raytrace.primary_samples;
let aa = crate::ui_kit::dropdown_menu(ui, "render_cpu_samples", &format!("{samples}×"), |ui| {
for count in [1, 4, 16] {
let handle = format!("render:aa-{count}");
let response = crate::ui_kit::list_picker(ui, &handle, &format!("{count}×"), count == samples);
crate::scenario::publish_handle(&handle, response.rect.center());
if response.clicked() {
app.render_workspace.view.raytrace.primary_samples = count;
ui.close();
}
}
});
crate::scenario::publish_handle("render:aa", aa.rect.center());
ui.small(app.tr("render.cpu_aa_help"));
});
}
#[cfg(test)]
fn cpu_lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
ui.label(app.tr("render.cpu_lighting"));
let presets = [
(LightingPreset::Neutral, "render.cpu_neutral"),
(LightingPreset::WarmCool, "render.cpu_warm_cool"),
(LightingPreset::KeyRim, "render.cpu_key_rim"),
];
let selected = app.render_workspace.view.raytrace.preset.unwrap_or(LightingPreset::Neutral);
let label = app
.tr(match selected {
LightingPreset::Neutral => "render.cpu_neutral",
LightingPreset::WarmCool => "render.cpu_warm_cool",
LightingPreset::KeyRim => "render.cpu_key_rim",
})
.to_string();
crate::ui_kit::dropdown_menu(ui, "render_cpu_lighting", &label, |ui| {
for (preset, key) in presets {
if crate::ui_kit::list_picker(ui, key, app.tr(key), preset == selected).clicked() {
app.render_workspace.view.raytrace.preset = Some(preset);
app.render_workspace.view.raytrace.lights = None;
ui.close();
}
}
});
let shadows = app.tr("render.cpu_shadows").to_string();
crate::ui_kit::checkbox(ui, &shadows, &mut app.render_workspace.view.raytrace.shadows);
}
#[cfg(test)]
fn image_method_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
method_selector(app, ui);
if app.render_workspace.view.method != ImageMethod::CpuRaytrace {
return;
}
cpu_sampling_controls(app, ui);
cpu_lighting_controls(app, ui);
ui.label(app.tr("render.image_exposure"));
let exposure_help = app.tr("render.cpu_exposure_help").to_string();
crate::ui_kit::number_field(ui, &mut app.render_workspace.view.draft.exposure_ev, -32.0..=32.0, 0.1, " EV").backing_on_hover_text(exposure_help);
cpu::controls(app, ui);
}
#[cfg(test)]
fn image_edit_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
ui.heading(app.tr("render.image_title"));
let preview = app.tr("render.result_preview").to_string();
let result = app.tr("render.result_title").to_string();
let mut selected = usize::from(app.render_workspace.view.result);
if crate::ui_kit::segmented(ui, &mut selected, &[&preview, &result], crate::ui_kit::Segments { compact: true, ..Default::default() }) {
let _ = app.run("render.result.view", json!({"view":if selected == 1 {"image"} else {"model"}}));
}
if app.render_workspace.view.result {
ui.horizontal(|ui| {
if crate::ui_kit::button(ui, app.tr("render.result_fit"), crate::ui_kit::Button::Normal).clicked() {
let _ = app.run("render.result.view", json!({"view":"fit"}));
}
if crate::ui_kit::button(ui, crate::i18n::tr("render.result_actual_size"), crate::ui_kit::Button::Enabled(!reduced_display(app)))
.backing_on_hover_text(app.tr("render.result_actual_help"))
.clicked()
{
let _ = app.run("render.result.view", json!({"view":"actual"}));
}
});
ui.small(app.tr("render.result_navigation"));
}
image_method_controls(app, ui);
ui.small(app.tr(match app.render_workspace.view.method {
ImageMethod::Raster => "render.opaque_image_summary",
ImageMethod::CpuRaytrace => "render.cpu_summary",
ImageMethod::GpuRaytrace => "render.progressive_image_summary",
}));
// The field's hard range never silently clamps a draft when its budget changes.
let side = match app.render_workspace.view.method {
ImageMethod::CpuRaytrace => 16384,
ImageMethod::GpuRaytrace => 8192,
ImageMethod::Raster => 4096,
};
ui.horizontal(|ui| {
ui.label(app.tr("render.image_width"));
if crate::ui_kit::number_field(ui, &mut app.render_workspace.view.draft.width, 1..=side, 1.0, "").changed() {
app.render_workspace.view.dirty = true;
}
ui.label(app.tr("render.image_height"));
if crate::ui_kit::number_field(ui, &mut app.render_workspace.view.draft.height, 1..=side, 1.0, "").changed() {
app.render_workspace.view.dirty = true;
}
});
let draft = &app.render_workspace.view.draft;
let size = (u64::from(draft.width), u64::from(draft.height));
if let Some((w, h)) = cpu::image_limits(app).fit(size.0, size.1, None)
&& (w, h) != size
{
let limit = if app.render_workspace.view.method == ImageMethod::CpuRaytrace && app.render_workspace.view.raytrace.progressive.is_some() {
"render.cpu_budget_resize"
} else {
"render.image_too_large"
};
ui.small(app.tr(limit));
if crate::ui_kit::button(ui, format!("{} {w} × {h}", app.tr("render.image_use_largest")), crate::ui_kit::Button::Normal).clicked() {
app.render_workspace.view.draft.width = u32::try_from(w).unwrap_or(1);
app.render_workspace.view.draft.height = u32::try_from(h).unwrap_or(1);
app.render_workspace.view.dirty = true;
}
}
match &app.render_workspace.path_host {
PathHost::Preparing(_, started) => setup_progress(ui, app, *started),
PathHost::Failed(error) => {
ui.add(egui::Label::new(format!("{}: {error}", app.tr("render.gpu_path_failed"))).wrap());
retry_crashed_setup(app, ui);
}
_ => {}
}
if app.render_workspace.view.method == ImageMethod::GpuRaytrace {
ui.label(app.tr("render.image_samples"));
// Powers of two from 1 to 4096; requests from elsewhere keep any count.
let samples = &mut app.render_workspace.view.samples;
let mut exponent = (*samples).max(1).ilog2().min(MAX_SAMPLES_EXPONENT);
let slider = crate::ui_kit::Slider { integer: true, format: |e| format!("{}", 1u32 << (e as u32).min(31)), ..Default::default() };
if crate::ui_kit::slider(ui, &mut exponent, 0..=MAX_SAMPLES_EXPONENT, slider).changed() {
*samples = 1 << exponent.min(MAX_SAMPLES_EXPONENT);
}
let title = app.tr("render.image_advanced").to_string();
crate::ui_kit::section(ui, "render_gpu_advanced", &title, false, |ui| {
ui.label(app.tr("render.gpu_depth"));
crate::ui_kit::number_field(ui, &mut app.render_workspace.view.max_depth, 1..=16, 1.0, "");
ui.label(app.tr("render.gpu_seed"));
crate::ui_kit::number_field(ui, &mut app.render_workspace.view.seed, 0..=u32::MAX, 1.0, "");
ui.label(app.tr("render.image_exposure"));
crate::ui_kit::number_field(ui, &mut app.render_workspace.view.draft.exposure_ev, -32.0..=32.0, 0.1, " EV");
ui.small(app.tr("render.gpu_options_help"));
studio::controls(app, ui);
studio::backdrop_controls(app, ui);
});
}
library::controls(app, ui);
materials::controls(app, ui);
let transparent_label = app.tr("render.image_transparent").to_string();
crate::ui_kit::checkbox(ui, &transparent_label, &mut app.render_workspace.view.transparent);
}
/// Dense all-controls composition, also useful to standalone/offscreen hosts.
#[cfg(test)]
fn image_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
image_edit_controls(app, ui);
job_controls(app, ui, false);
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 {
if let Err(error) = ¶ms {
ui.add(egui::Label::new(egui::RichText::new(error).color(Tokens::get().warning)).wrap());
}
cpu::checked_status(app, ui, params.as_ref().ok());
}
let mut busy = false;
let mut state = None;
if let Some(job) = app.render_workspace.view.job {
match app.session.execute("render.status", &json!({"job":job})) {
Ok(status) => {
let phase = status["progress"]["phase"].as_str().unwrap_or(crate::i18n::tr("render.property_unknown"));
busy = matches!(phase, "queued" | "preparing" | "running" | "encoding" | "cancelling");
state = Some(status);
}
Err(error) => {
if !compact {
ui.add(egui::Label::new(egui::RichText::new(error.to_string()).small()).wrap());
}
}
}
}
ui.horizontal_wrapped(|ui| {
let check = crate::ui_kit::button(
ui,
app.tr("cmd.render_preflight"),
crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.preflight").is_ok()),
);
crate::scenario::publish_target("render:check", check.rect);
if check.clicked()
&& let Err(error) = ribbon::perform_job(app, "render.preflight")
{
app.set_status(error, true);
}
let start = crate::ui_kit::button(
ui,
app.tr("render.image_start"),
crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.start").is_ok()),
);
crate::scenario::publish_target("render:start", start.rect);
if start.clicked() {
if let Err(error) = ribbon::perform_job(app, "render.start") {
app.set_status(error, true);
}
ui.ctx().request_repaint();
}
});
let message = state.as_ref().map_or_else(
|| app.tr(if params.is_ok() { "render.studio_ready" } else { "render.studio_needs_review" }).to_string(),
|status| {
app.tr(match status["progress"]["phase"].as_str().unwrap_or("") {
"queued" => "render.image_queued",
"preparing" => "render.image_preparing",
"running" => "render.image_running",
"encoding" => "render.image_encoding",
"cancelling" => "render.image_cancelling",
"cancelled" => "render.image_cancelled",
"completed" => "render.image_completed",
"failed" => "render.image_failed",
_ => "render.image_unknown",
})
.to_string()
},
);
let response = ui.add_sized([ui.available_width(), ui.text_style_height(&egui::TextStyle::Body)], egui::Label::new(message).truncate());
crate::scenario::publish_target("render:job-summary", response.rect);
if let Err(error) = ¶ms {
response.backing_on_hover_text(error);
}
if let Some(status) = &state {
if !compact {
cpu::captured_status(app, ui, status);
if let Some(message) = status["error"]["message"].as_str() {
ui.add(egui::Label::new(egui::RichText::new(message).small()).wrap());
}
}
if busy {
let done = status["progress"]["done"].as_u64().unwrap_or(0);
let total = status["progress"]["total"].as_u64().unwrap_or(1).max(1);
crate::ui_kit::progress(ui, "render", (done as f64 / total as f64).clamp(0.0, 1.0) as f32);
ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
}
}
ui.horizontal_wrapped(|ui| {
let cancel = crate::ui_kit::button(
ui,
app.tr("cmd.render_cancel"),
crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.cancel").is_ok()),
);
crate::scenario::publish_target("render:cancel", cancel.rect);
if cancel.clicked()
&& let Err(error) = ribbon::perform_job(app, "render.cancel")
{
app.set_status(error, true);
}
let export = crate::ui_kit::button(
ui,
app.tr("render.image_export"),
crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.export").is_ok()),
);
crate::scenario::publish_target("render:export", export.rect);
if export.clicked()
&& let Err(error) = ribbon::perform_job(app, "render.export")
{
app.set_status(error, true);
}
});
if !compact {
let label = app.tr("render.image_overwrite").to_string();
crate::ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.overwrite);
}
}
/// Decode each published sequence once. Provisional textures stay separate from the last
/// final image, so cancellation or a failed pass cannot change the export target.
#[cfg(test)]
fn completed_image(app: &mut SolveApp, ui: &mut egui::Ui) {
cache_render_images(app, ui.ctx());
if let Some(display) = displayed_image(app) {
if display.preview.is_some() {
ui.small(app.tr("render.result_provisional"));
}
match display.image {
Ok(texture) => {
if ui
.add(egui::Image::new(texture).max_size(egui::vec2(ui.available_width(), 240.0)).shrink_to_fit().sense(Sense::click()))
.backing_on_hover_text(app.tr("render.result_open"))
.clicked()
{
let _ = app.run("render.result.view", json!({"view":"image"}));
}
}
Err(error) => {
ui.add(egui::Label::new(error).wrap());
}
}
} else if let Some((_, Err(error))) = &app.render_workspace.image {
ui.add(egui::Label::new(error).wrap());
}
}
fn cache_completed_image(app: &mut SolveApp, ctx: &egui::Context) {
let Some(job) = app.render_workspace.view.completed else {
app.render_workspace.image = None;
app.render_workspace.image_info = None;
return;
};
if app.render_workspace.image.as_ref().is_none_or(|(old, _)| *old != job) {
app.render_workspace.image_info = None;
let result = (|| -> Result<egui::TextureHandle, String> {
let handle = app.session.render_job_handle(job).map_err(|e| e.to_string())?;
let frame = handle.frame().map_err(|e| e.to_string())?.ok_or(crate::i18n::tr("render.error_no_completed_image"))?;
if let Some((_, cached)) = app.render_workspace.comparison_images.iter().find(|(id, _)| *id == job) {
let texture = cached.clone()?;
app.render_workspace.image_info = Some(frame.info.clone());
return Ok(texture);
}
let captured = handle.status().map_err(|e| e.to_string())?;
let budget = if frame.info.executor.as_str() == "gpu-path" {
solidcraft_engine::render::job::GPU_PATH_LIMITS
} else {
captured_image_limits(&captured.request)
};
let image = decode_render_image(frame.png(), frame.info.width, frame.info.height, budget, ctx.input(|i| i.max_texture_side))?;
app.render_workspace.image_info = Some(frame.info.clone());
Ok(ctx.load_texture("sc_render_image", image, egui::TextureOptions::LINEAR))
})();
// Cache errors too, so a bad frame cannot repeatedly allocate or decode on repaint.
app.render_workspace.image = Some((job, result));
}
}
fn displayed_image(app: &SolveApp) -> Option<DisplayImage<'_>> {
let state = &app.render_workspace;
if let Some(preview) = &state.preview_image
&& state.view.job == Some(preview.info.frame.job)
{
return Some(DisplayImage { info: &preview.info.frame, image: &preview.image, preview: Some(&preview.info) });
}
Some(DisplayImage { info: state.image_info.as_ref()?, image: &state.image.as_ref()?.1, preview: None })
}
fn captured_adaptive_preview(
status: &solidcraft_engine::render::job::JobStatus,
completed: u32,
) -> Result<Option<solidcraft_engine::render::job::adaptive::AdaptivePreview>, String> {
use solidcraft_engine::render::job::adaptive::AdaptivePreview;
if status.request.integrator == Integrator::Raytrace && status.resolved.executor.as_str() != "gpu-path" {
let Some(options) = &status.request.raytrace else {
return Ok(None);
};
options
.adaptive
.as_deref()
.map(|adaptive| {
let maximum = options.progressive.ok_or_else(|| crate::i18n::tr("render.error_provisional_identity").to_string())?.samples_per_pixel;
AdaptivePreview::captured(*adaptive, maximum, completed).map_err(|error| error.to_string())
})
.transpose()
} else {
AdaptivePreview::at(status.options, completed).map_err(|error| error.to_string())
}
}
fn cache_preview_frame(app: &mut SolveApp, ctx: &egui::Context, info: &PreviewInfo, png: &[u8]) {
if app.render_workspace.view.job != Some(info.frame.job) {
return;
}
if app
.render_workspace
.preview_image
.as_ref()
.is_some_and(|old| old.info.frame.job == info.frame.job && old.info.frame_sequence >= info.frame_sequence)
{
return;
}
let result = (|| -> Result<egui::TextureHandle, String> {
if info.frame_sequence == 0 || info.samples_per_pixel == 0 {
return Err(crate::i18n::tr("render.error_provisional_identity").into());
}
let handle = app.session.render_job_handle(info.frame.job).map_err(|e| e.to_string())?;
let captured = handle.status().map_err(|e| e.to_string())?;
if (info.frame.width, info.frame.height) != (captured.request.width, captured.request.height) {
return Err(crate::i18n::tr("render.error_checkpoint_dimensions").into());
}
if info.frame.executor != captured.resolved.executor || info.frame.scene_generation != captured.scene_generation {
return Err(crate::i18n::tr("render.error_provisional_identity").into());
}
let limits = if info.frame.executor.as_str() == "gpu-path" {
let target = captured.options.preview_target().map_err(|e| e.to_string())?;
let adaptive =
solidcraft_engine::render::job::adaptive::AdaptivePreview::at(captured.options, info.samples_per_pixel).map_err(|e| e.to_string())?;
if info.samples_per_pixel >= target || info.adaptive != adaptive {
return Err(crate::i18n::tr("render.error_provisional_identity").into());
}
solidcraft_engine::render::job::GPU_PATH_LIMITS
} else {
let adaptive = captured_adaptive_preview(&captured, info.samples_per_pixel)?;
let exceeds_target = adaptive.is_some()
&& info.samples_per_pixel
>= captured.request.raytrace.as_ref().map_or(Ok(0), RaytraceOptions::preview_target).map_err(|e| e.to_string())?;
if exceeds_target || info.adaptive != adaptive {
return Err(crate::i18n::tr("render.error_provisional_identity").into());
}
let options = solidcraft_engine::render::job::CpuProgressiveOptions { samples_per_pixel: info.samples_per_pixel, seed: 0 };
options
.validate_image_with_budget(info.frame.width, info.frame.height, captured.request.cpu_budget())
.map_err(|error| error.to_string())?;
captured_image_limits(&captured.request)
};
let image = decode_render_image(png, info.frame.width, info.frame.height, limits, ctx.input(|i| i.max_texture_side))?;
Ok(ctx.load_texture("sc_render_preview", image, egui::TextureOptions::LINEAR))
})();
// Cache errors by identity too: a malformed publication cannot decode on every repaint.
app.render_workspace.preview_image = Some(PreviewImage { info: info.clone(), image: result });
}
fn cache_preview_image(app: &mut SolveApp, ctx: &egui::Context) {
if app.render_workspace.view.follow_job
&& let Some(job) = app.render_workspace.view.job
&& let Ok(handle) = app.session.render_job_handle(job)
{
let preview = handle.preview().ok().flatten();
// Read the final after the checkpoint: completion may occur after the panel's
// earlier status query. Promote the real final before dropping its preview,
// rather than briefly falling back to an older job and losing result framing.
if handle.frame().ok().flatten().is_none()
&& let Some(preview) = preview
{
cache_preview_frame(app, ctx, &preview.info, preview.png());
return;
}
}
app.render_workspace.preview_image = None;
}
fn remember_displayed_job(app: &mut SolveApp, preserve_view: bool) {
let Some(job) = displayed_image(app).map(|display| display.info.job) else {
return;
};
if app.render_workspace.view.result_job != Some(job) {
app.render_workspace.view.result_job = Some(job);
if !preserve_view {
app.render_workspace.view.result_scale = ResultScale::Fit;
app.render_workspace.view.result_domain = None;
}
}
}
fn cache_render_images(app: &mut SolveApp, ctx: &egui::Context) {
let preserve_view = app.render_workspace.preview_image.as_ref().is_some_and(|preview| {
app.render_workspace.view.result_job == Some(preview.info.frame.job) && app.render_workspace.view.job == Some(preview.info.frame.job)
});
cache_preview_image(app, ctx);
sync_results(app);
cache_completed_image(app, ctx);
// Checkpoint updates and preview→final/cancel transitions preserve shared pan/zoom.
remember_displayed_job(app, preserve_view);
finish_auto_result(app);
}
fn finish_auto_result(app: &mut SolveApp) {
use solidcraft_engine::render::job::Phase;
let Some(auto) = &app.render_workspace.view.auto_result_job else {
return;
};
if app.render_workspace.view.job != Some(auto.job) {
app.render_workspace.view.auto_result_job = None;
return;
}
let handle = auto.handle.clone();
let Ok(status) = handle.status() else { return };
if !matches!(status.progress.phase, Phase::Completed | Phase::Cancelled | Phase::Failed) {
return;
}
let view = &mut app.render_workspace.view;
view.auto_result_job = None;
if matches!(status.progress.phase, Phase::Cancelled | Phase::Failed)
&& !app.preferences.render_legacy_image_defaults
&& view.result
&& view.follow_job
&& view.compare.is_none()
&& view.completed.is_none()
{
// The automatically opened viewer has neither a final nor a valid checkpoint.
// Resume the product canvas before live::tick observes its suspension state.
view.result = false;
live::drain_final(app, handle);
if let Some(error) = status.error {
app.set_status(error.to_string(), true);
}
}
}
fn sync_results(app: &mut SolveApp) {
let Ok(mut results) = app.session.render_retained_results() else {
return;
};
let view = &mut app.render_workspace.view;
for result in &mut results {
if result.shot.is_none() {
result.shot = view.retained.iter().find(|old| old.frame.job == result.frame.job).and_then(|old| old.shot.clone());
if result.shot.is_none() && view.job == Some(result.frame.job) {
result.shot = view.job_shot.clone();
}
}
}
view.retained = results;
view.completed = app.session.render_selected_result();
if view.compare.as_ref().is_some_and(|comparison| {
[comparison.left, comparison.right].into_iter().flatten().any(|job| !view.retained.iter().any(|result| result.frame.job == job))
}) {
view.compare = None;
app.render_workspace.comparison_images.clear();
}
}
fn follow_batch(app: &mut SolveApp) {
let queue = app.session.render_queue_state();
follow_batch_view(&mut app.render_workspace.view, queue);
}
fn follow_batch_view(view: &mut ViewState, queue: solidcraft_engine::render_jobs::RenderQueueState) {
if let Some(job) = queue.job {
if view.job != Some(job) {
view.follow_job = view.compare.is_none();
}
view.job = Some(job);
view.job_shot = queue.shot;
}
}
fn captured_image_limits(request: &solidcraft_engine::render::job::ImageRequest) -> RenderLimits {
if request.integrator == Integrator::Raytrace {
request.cpu_budget().image_limits(request.raytrace.as_ref().is_some_and(|o| o.progressive.is_some()))
} else {
RenderLimits::default()
}
}
/// This is a display cache only: the authoritative PNG/frame and export remain
/// full resolution. Avoid asking a viewport device for an unsupported texture.
fn display_dimensions(width: u32, height: u32, max_texture_side: usize) -> Result<(u32, u32), String> {
if width == 0 || height == 0 || max_texture_side == 0 {
return Err(crate::i18n::tr("render.error_display_dimensions").into());
}
let max_side = max_texture_side.min(8192) as u64;
let display = RenderLimits { max_dimension: max_side, max_pixels: 16_777_216, max_scratch_bytes: 512 * 1024 * 1024 };
let (w, h) = display.fit(u64::from(width), u64::from(height), None).ok_or(crate::i18n::tr("render.error_display_fit"))?;
Ok((
u32::try_from(w).map_err(|_| crate::i18n::tr("render.error_display_width"))?,
u32::try_from(h).map_err(|_| crate::i18n::tr("render.error_display_height"))?,
))
}
#[cfg(test)]
fn decode_image(png: &[u8], width: u32, height: u32) -> Result<egui::ColorImage, String> {
decode_render_image(png, width, height, RenderLimits::default(), 8192)
}
fn decode_render_image(png: &[u8], width: u32, height: u32, budget: RenderLimits, max_texture_side: usize) -> Result<egui::ColorImage, String> {
let size = (u64::from(width), u64::from(height));
if budget.fit(size.0, size.1, None) != Some(size) {
return Err(crate::i18n::tr("render.error_image_profile").into());
}
let display_size = display_dimensions(width, height, max_texture_side)?;
let mut reader = image::ImageReader::with_format(std::io::Cursor::new(png), image::ImageFormat::Png);
let mut limits = image::Limits::default();
limits.max_image_width = Some(width);
limits.max_image_height = Some(height);
limits.max_alloc = Some(size.0.checked_mul(size.1).and_then(|n| n.checked_mul(16)).ok_or(crate::i18n::tr("render.error_decode_budget"))?);
reader.limits(limits);
let image = reader.decode().map_err(|e| e.to_string())?.to_rgba8();
if image.dimensions() != (width, height) {
return Err(crate::i18n::tr("render.error_image_dimensions").into());
}
let image = if display_size != (width, height) {
image::imageops::resize(&image, display_size.0, display_size.1, image::imageops::FilterType::Triangle)
} else {
image
};
Ok(egui::ColorImage::from_rgba_unmultiplied([display_size.0 as usize, display_size.1 as usize], image.as_raw()))
}
fn reduced_display(app: &SolveApp) -> bool {
displayed_image(app).is_some_and(|display| {
display.image.as_ref().is_ok_and(|texture| texture.size() != [display.info.width as usize, display.info.height as usize])
})
}
/// The image has its own per-document orthographic camera. Shared navigation can temporarily
/// drive it without changing the product camera, saved setup, or a pending Design view.
pub(crate) fn with_result_camera(app: &mut SolveApp, navigate: impl FnOnce(&mut SolveApp)) {
let preview = std::mem::replace(&mut app.cam, app.render_workspace.view.result_camera);
let before = app.cam;
let draft = app.render_workspace.view.draft.clone();
let dirty = app.render_workspace.view.dirty;
let perspective = std::mem::replace(&mut app.ui.perspective, false);
let up = app.ui.up_axis;
let animation = app.cam_anim.take();
let pending = app.pending_fit.take();
let request = app.session.camera.take();
let free = app.viewport.orbit_free.take();
let spin = std::mem::replace(&mut app.viewport.spin, false);
navigate(app);
app.render_workspace.view.result_camera = std::mem::replace(&mut app.cam, preview);
if app.render_workspace.view.result_camera != before {
app.render_workspace.view.result_scale = ResultScale::Free;
app.render_workspace.view.result_domain = None;
}
app.render_workspace.view.draft = draft;
app.render_workspace.view.dirty = dirty;
app.ui.perspective = perspective;
app.ui.up_axis = up;
app.cam_anim = animation;
app.pending_fit = pending;
app.session.camera = request;
app.viewport.orbit_free = free;
app.viewport.spin = spin;
}
fn result_camera(size: [u32; 2], rect: egui::Rect, pixels_per_point: f32, scale: ResultScale) -> Camera {
let width = f64::from(size[0].max(1));
let height = f64::from(size[1].max(1));
let scale = if scale == ResultScale::Actual {
1.0 / f64::from(pixels_per_point.max(0.1))
} else {
(f64::from((rect.width() - 32.0).max(1.0)) / width).min(f64::from((rect.height() - 32.0).max(1.0)) / height)
};
Camera {
yaw: 0.0,
pitch: std::f64::consts::FRAC_PI_2,
distance: (f64::from(rect.height().max(1.0)) / (0.8 * scale)).clamp(1e-3, 1e7),
..Default::default()
}
}
fn result_rect(camera: Camera, size: [u32; 2], canvas: egui::Rect) -> egui::Rect {
let scale = f64::from(canvas.height().max(1.0)) / (2.0 * camera.half_height());
let center = canvas.center() + egui::vec2((-camera.target.x * scale) as f32, (camera.target.y * scale) as f32);
egui::Rect::from_center_size(center, egui::vec2((f64::from(size[0]) * scale) as f32, (f64::from(size[1]) * scale) as f32))
}
fn result_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
if app.universal_panel_host_enabled() {
// The comparison picker contains scoped controls (including Swap). Give
// that compound widget its own row, then wrap actions at the original
// viewport width even if the picker needs horizontal scrolling.
let width = ui.available_width();
let layout = if ui.layout().prefer_right_to_left() {
egui::Layout::right_to_left(egui::Align::Center)
} else {
egui::Layout::left_to_right(egui::Align::Center)
};
ui.horizontal(|ui| compare::controls(app, ui));
ui.allocate_ui_with_layout(egui::vec2(width, Tokens::get().control_height), layout.with_main_wrap(true), |ui| {
result_action_controls(app, ui)
});
return;
}
classic_result_actions(app, ui);
}
/// Keep enabled state on the wrapping UI itself. Button::Enabled opens a child
/// scope in the remaining row space, so its button cannot wrap in the parent.
/// Classic retains the original kit path and widget identities.
fn result_action_button(ui: &mut egui::Ui, label: &str, enabled: bool, host: bool) -> egui::Response {
if host {
ui.add_enabled(enabled, |ui: &mut egui::Ui| crate::ui_kit::button(ui, label, crate::ui_kit::Button::Normal))
} else {
crate::ui_kit::button(ui, label, crate::ui_kit::Button::Enabled(enabled))
}
}
fn result_action_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
crate::scenario::publish_rect("render:result-actions-clip", ui.clip_rect());
let host = app.universal_panel_host_enabled();
let results = app.render_workspace.view.retained.clone();
if !results.is_empty() {
let selected = results.iter().position(|result| Some(result.frame.job) == app.render_workspace.view.completed);
let label = selected.and_then(|index| results.get(index)).map(result_label).unwrap_or_else(|| app.tr("render.results_choose").to_string());
let mut chosen = None;
let t = Tokens::get();
let width = (ui.available_width() - t.control_height - ui.spacing().item_spacing.x).max(t.control_height);
let picker = crate::ui_kit::bounded_dropdown_menu(ui, "render_results", &label, width, |ui| {
for (index, result) in results.iter().enumerate().rev() {
let item_label = result_label(result);
let response = crate::ui_kit::list_picker(ui, &format!("result:{index}"), &item_label, selected == Some(index));
crate::scenario::publish_target(&format!("render:result:select:{index}"), response.rect);
if response.clicked() {
chosen = Some(index);
ui.close();
}
response.on_hover_text(item_label);
}
});
let picker = picker.on_hover_text(&label);
crate::scenario::publish_target("render:results", picker.rect);
if let Some(index) = chosen {
let _ = app.run("render.result.select", json!({"index":index}));
}
let discard = if host {
ui.add_enabled(selected.is_some(), |ui: &mut egui::Ui| {
crate::ui_kit::StageBar::icon_action(ui, "delete", app.tr("cmd.render.result.discard"))
})
} else {
ui.add_enabled_ui(selected.is_some(), |ui| crate::ui_kit::StageBar::icon_action(ui, "delete", app.tr("cmd.render.result.discard"))).inner
};
crate::scenario::publish_target("render:result-discard", discard.rect);
if discard.clicked()
&& let Some(index) = selected
{
let _ = app.run("render.result.discard", json!({"index":index}));
}
}
for (view, key) in [("model", "render.state_model"), ("fit", "render.output_fit"), ("actual", "render.result_actual")] {
let enabled = view != "actual" || !reduced_display(app);
let response = result_action_button(ui, app.tr(key), enabled, host);
crate::scenario::publish_target(&format!("render:result-{view}"), response.rect);
crate::scenario::publish_target(&format!("render:result:view:{view}"), response.rect);
if response.clicked() {
let _ = app.run("render.result.view", json!({"view":view}));
}
}
let copy = result_action_button(ui, app.tr("render.output_copy"), ribbon::action_ready(app, "render.result.copy").is_ok(), host);
crate::scenario::publish_target("render:result-copy", copy.rect);
if copy.clicked() {
app.start("render.result.copy");
}
let export = result_action_button(ui, studio::export_label(app), ribbon::action_ready(app, "render.export").is_ok(), host);
crate::scenario::publish_target("render:result-export", export.rect);
if export.clicked() {
app.start("render.export");
}
let close = crate::ui_kit::StageBar::icon_action(ui, "close", app.tr("cmd.render_result_close"));
crate::scenario::publish_target("render:result-close", close.rect);
if close.clicked() {
app.start("render.result.close");
}
}
fn classic_result_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
// Each independently sized control group begins in the original free width.
// A ComboBox width is a minimum; placing it after the comparison strip in a
// wrapped row can otherwise move its entire hit target under the inspector.
ui.horizontal_wrapped(|ui| compare::controls(app, ui));
let results = app.render_workspace.view.retained.clone();
if !results.is_empty() {
ui.horizontal_wrapped(|ui| {
let selected = results.iter().position(|result| Some(result.frame.job) == app.render_workspace.view.completed);
let label =
selected.and_then(|index| results.get(index)).map(result_label).unwrap_or_else(|| app.tr("render.results_choose").to_string());
let mut chosen = None;
let t = Tokens::get();
let width = (ui.available_width() - t.control_height - ui.spacing().item_spacing.x).max(t.control_height);
let picker = crate::ui_kit::bounded_dropdown_menu(ui, "render_results", &label, width, |ui| {
for (index, result) in results.iter().enumerate().rev() {
let label = result_label(result);
let response = crate::ui_kit::list_picker(ui, &format!("result:{index}"), &label, selected == Some(index));
crate::scenario::publish_target(&format!("render:result:select:{index}"), response.rect);
if response.clicked() {
chosen = Some(index);
ui.close();
}
response.on_hover_text(label);
}
});
let picker = picker.on_hover_text(&label);
crate::scenario::publish_target("render:results", picker.rect);
if let Some(index) = chosen {
let _ = app.run("render.result.select", json!({"index":index}));
}
let discard = ui
.add_enabled_ui(selected.is_some(), |ui| crate::ui_kit::StageBar::icon_action(ui, "delete", app.tr("cmd.render.result.discard")))
.inner;
crate::scenario::publish_target("render:result-discard", discard.rect);
if discard.clicked()
&& let Some(index) = selected
{
let _ = app.run("render.result.discard", json!({"index":index}));
}
});
}
ui.horizontal_wrapped(|ui| {
for (view, key) in [("model", "render.state_model"), ("fit", "render.output_fit"), ("actual", "render.result_actual")] {
let enabled = view != "actual" || !reduced_display(app);
let response = crate::ui_kit::button(ui, app.tr(key), crate::ui_kit::Button::Enabled(enabled));
crate::scenario::publish_target(&format!("render:result:view:{view}"), response.rect);
crate::scenario::publish_target(&format!("render:result-{view}"), response.rect);
if response.clicked() {
let _ = app.run("render.result.view", json!({"view":view}));
}
}
let copy = crate::ui_kit::button(
ui,
app.tr("render.output_copy"),
crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.result.copy").is_ok()),
);
crate::scenario::publish_target("render:result-copy", copy.rect);
if copy.clicked() {
app.start("render.result.copy");
}
let export =
crate::ui_kit::button(ui, studio::export_label(app), crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.export").is_ok()));
crate::scenario::publish_target("render:result-export", export.rect);
if export.clicked() {
app.start("render.export");
}
let close = crate::ui_kit::StageBar::icon_action(ui, "close", app.tr("cmd.render_result_close"));
crate::scenario::publish_target("render:result-close", close.rect);
if close.clicked() {
app.start("render.result.close");
}
});
}
fn result_label(result: &solidcraft_engine::render_jobs::RetainedResult) -> String {
let name = result.shot.as_deref().unwrap_or_else(|| crate::i18n::tr("render.results_unnamed"));
let label = crate::i18n::format(
"render.results_label",
&[("number", &result.frame.job.serial.to_string()), ("shot", name), ("seconds", &format!("{:.0}", result.seconds))],
);
if result.stale { crate::i18n::format("render.results_stale_label", &[("result", &label)]) } else { label }
}
fn result_header(app: &mut SolveApp, ui: &mut egui::Ui) {
let t = Tokens::get();
let display = displayed_image(app).map(|display| (display.info.clone(), display.preview.cloned()));
let state = match &display {
Some((_, Some(_))) => "render.state_in_progress",
Some(_) => "render.state_completed",
None if ribbon::busy(app) => "render.state_in_progress",
None => "render.result_title",
};
crate::ui_kit::text(ui, app.tr(state), crate::ui_kit::Text::Inline);
result_actions(app, ui);
let Some((info, preview)) = display else {
return;
};
if let Some(preview) = &preview {
let target = app
.session
.render_job_handle(preview.frame.job)
.ok()
.and_then(|handle| handle.status().ok())
.map(|status| {
if preview.frame.executor.as_str() == "gpu-path" {
status.options.samples
} else {
status.request.raytrace.as_ref().and_then(|options| options.preview_target().ok()).unwrap_or(preview.samples_per_pixel)
}
})
.unwrap_or(preview.samples_per_pixel);
let message = if let Some(adaptive) = preview.adaptive {
format!(
"{} · {} · {} {}",
app.tr("render.result_provisional"),
adaptive_preview_label(app, adaptive),
app.tr("render.result_sequence"),
preview.frame_sequence
)
} else {
format!(
"{} · {} / {} {} · {} {}",
app.tr("render.result_provisional"),
preview.samples_per_pixel,
target,
app.tr("render.cpu_progressive_spp"),
app.tr("render.result_sequence"),
preview.frame_sequence
)
};
ui.colored_label(t.warning, message);
if preview.adaptive.is_some() {
ui.small(app.tr("render.adaptive.preview_help"));
}
ui.small(app.tr("render.result_provisional_help"));
}
if let Some(display) = displayed_image(app)
&& let Err(error) = display.image
{
ui.colored_label(t.warning, error);
}
ui.horizontal_wrapped(|ui| {
ui.strong(format!("{} × {} px · PNG · {}", info.width, info.height, info.executor.as_str()));
ui.label(format!(
"{} {}:{}:{} · {} {}",
app.tr("render.result_job"),
info.job.session,
info.job.serial,
info.job.generation,
app.tr("render.result_capture"),
info.scene_generation
));
});
if reduced_display(app) {
ui.colored_label(t.warning, app.tr("render.result_reduced_display"));
}
let stale = info.scene_generation != app.session.revision;
ui.colored_label(if stale { t.warning } else { t.text_dim }, app.tr(if stale { "render.image_stale" } else { "render.result_current" }));
if app.render_workspace.view.job.is_some_and(|job| job != info.job) {
ui.small(app.tr("render.result_retained"));
}
}
/// Result controls remain legacy chrome. Paint them after the shell, inside a
/// real free contour piece, and record only the clipped card actually shown.
/// No panel adapter, outer host or second navigation path is introduced.
pub(crate) fn host_result_overlays(app: &mut SolveApp, ui: &mut egui::Ui) {
use crate::panel_runtime::{egui_rect, logical_rect};
crate::shell::register_panel(app, "render:result-controls", None, None);
if !app.universal_panel_host_enabled() || !active(app) || (!result_active(app) && app.render_workspace.view.compare.is_none()) {
return;
}
let Some(canvas) = app.viewport.rect.filter(|rect| rect.is_finite() && rect.is_positive()) else {
return;
};
crate::viewport::refresh_layout(app, ui.ctx());
if !crate::render_ui::focused(app)
&& let Some(usable) = app.viewport.layout.as_ref().and_then(|layout| layout.usable.clone())
{
let t = Tokens::get();
// Use an existing sweep piece, as other host controls do. A maximum
// spanning rectangle search belongs to an explicit Fit, not each frame.
let room = usable.free.iter().max_by(|a, b| (a.size.width * a.size.height).total_cmp(&(b.size.width * b.size.height))).copied();
if let Some(room) = room {
let mut bounds = egui_rect(room).intersect(canvas).shrink(t.space_4);
bounds.max.x = bounds.right().min(bounds.left() + t.form_card_width * 2.0);
if bounds.is_finite() && bounds.width() >= t.control_height + t.space_8 && bounds.height() >= t.control_height + t.space_8 {
let painted = host_result_card(app, ui, bounds, canvas);
if ui.is_visible() && !ui.is_sizing_pass() && painted.is_positive() && usable.contains_rect(logical_rect(painted)) {
crate::shell::register_panel(app, "render:result-controls", Some(painted), None);
crate::scenario::publish_rect("render:result-controls", painted);
}
}
}
}
crate::viewport::refresh_layout(app, ui.ctx());
if !result_active(app) && app.render_workspace.view.compare.is_none() {
app.render_workspace.result_navigation = None;
return;
}
update_host_result_camera(app, ui.ctx(), canvas);
if let Some((rect, response, captured)) = app.render_workspace.result_navigation.take()
&& !captured
&& !host_navigation_captured(app)
{
let before = app.render_workspace.view.result_camera;
with_result_camera(app, |app| {
crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps { orbit: false, pick: false });
});
if app.render_workspace.view.result_camera != before {
ui.ctx().request_repaint();
}
}
}
/// The existing legacy card, shared with bounded-widget regression fixtures.
/// The caller alone records its footprint and finalizes the canvas response.
fn host_result_card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect, canvas: egui::Rect) -> egui::Rect {
let t = Tokens::get();
let mut controls = ui.new_child(egui::UiBuilder::new().max_rect(bounds).id_salt("render_host_result_controls"));
controls.set_clip_rect(ui.clip_rect().intersect(bounds));
let card = crate::ui_kit::Container::navigation_contents(&mut controls, |ui| {
// A vertical-only ScrollArea grows to its child's minimum width,
// outside this card's clip. Oversized compound controls must scroll.
egui::ScrollArea::both()
.id_salt("render_host_result_scroll")
.min_scrolled_width(0.0)
.min_scrolled_height(0.0)
.max_width(ui.available_width())
.max_height((bounds.height().min(t.form_card_width) - t.space_8).max(0.0))
.show(ui, |ui| {
if app.render_workspace.view.compare.is_some() {
result_actions(app, ui);
compare::summary(app, ui);
} else {
result_header(app, ui);
}
let camera = app.render_workspace.view.result_camera;
let percent = f64::from(canvas.height() * ui.ctx().pixels_per_point()) / (2.0 * camera.half_height()) * 100.0;
ui.small(format!("{percent:.1}%"));
});
});
card.response.rect.intersect(controls.clip_rect())
}
fn host_navigation_captured(app: &SolveApp) -> bool {
// The root finishes host input after result navigation, so an existing
// header/resize capture still owns this pass even when Primary releases.
app.panel_runtime.as_ref().and_then(|runtime| runtime.host()).is_some_and(|host| host.interaction().is_captured())
}
/// Apply Fit/Actual only for an explicit request, a new image domain or DPI.
/// Ordinary panel moves cannot mutate either the image or product camera.
fn update_host_result_camera(app: &mut SolveApp, ctx: &egui::Context, canvas: egui::Rect) {
use crate::panel_runtime::egui_rect;
use solidcraft_engine::panels::Point;
let view = &app.render_workspace.view;
let size = if let Some(comparison) = &view.compare {
view.retained.iter().find(|result| result.frame.job == comparison.reference).map(|result| [result.frame.width, result.frame.height])
} else {
displayed_image(app).map(|display| [display.info.width, display.info.height])
};
let Some(size) = size else { return };
let scale = view.result_scale;
let domain = (canvas, size, ctx.pixels_per_point(), scale);
if scale == ResultScale::Free || view.result_domain == Some(domain) {
return;
}
let camera = if scale == ResultScale::Actual {
result_camera(size, canvas, ctx.pixels_per_point(), scale)
} else {
let Some(usable) = app.viewport.layout.as_ref().and_then(|layout| layout.usable.as_ref()) else {
return;
};
let aspect = size[0].max(1) as f32 / size[1].max(1) as f32;
let Some(room) = usable.fit_rect_with_clearance(aspect, Point { x: canvas.center().x, y: canvas.center().y }, Tokens::get().space_8) else {
return;
};
let room = egui_rect(room);
let mut camera = result_camera(size, room, ctx.pixels_per_point(), scale);
// Keep the existing image-scale formula, expressed in the full canvas.
camera.distance *= f64::from(canvas.height() / room.height());
let units = 2.0 * camera.half_height() / f64::from(canvas.height());
let offset = room.center() - canvas.center();
camera.target.x = -f64::from(offset.x) * units;
camera.target.y = f64::from(offset.y) * units;
camera
};
if camera.is_valid() {
app.render_workspace.view.result_camera = camera;
app.render_workspace.view.result_domain = Some(domain);
ctx.request_repaint();
}
}
fn show_result(app: &mut SolveApp, ui: &mut egui::Ui) {
cache_render_images(app, ui.ctx());
let t = Tokens::get();
ui.painter().rect_filled(ui.max_rect(), 0.0, t.viewport_bottom);
let host = app.universal_panel_host_enabled();
if !host {
// Classic framing and navigation cannot leave the host fit cache valid.
app.render_workspace.view.result_domain = None;
}
let viewport = ui.max_rect();
// The host image keeps its whole below-app-bar projection. Persistent
// controls paint later, after the legacy shell has registered real bounds.
let mut free = if host { viewport } else { crate::render_ui::canvas(app, viewport) };
if !host && ribbon::busy(app) {
free = crate::ui_kit::Container::below_navigation_row(free);
}
if host {
app.viewport.rect = Some(viewport);
crate::viewport::refresh_layout(app, ui.ctx());
}
let mut content = ui.new_child(egui::UiBuilder::new().max_rect(free).id_salt("render_result_content"));
content.set_clip_rect(free.intersect(ui.clip_rect()));
let ui = &mut content;
let Some(info) = displayed_image(app).map(|display| display.info.clone()) else {
let message = match &app.render_workspace.image {
Some((_, Err(error))) => error.clone(),
_ if ribbon::busy(app) => app.tr("render.state_in_progress").to_string(),
_ => app.tr("render.result_empty").to_string(),
};
if !host {
crate::ui_kit::Container::navigation_contents(ui, |ui| result_header(app, ui));
}
let unavailable = app
.render_workspace
.view
.job
.and_then(|job| app.session.render_job_handle(job).ok())
.and_then(|handle| handle.status().ok())
.and_then(|status| status.preview_unavailable_reason);
let canvas = ui.available_rect_before_wrap().intersect(free);
ui.centered_and_justified(|ui| {
ui.vertical_centered(|ui| {
ui.add(egui::Label::new(egui::RichText::new(message).size(t.font_heading).color(t.text)).wrap());
if ribbon::busy(app)
&& let Some(reason) = unavailable
{
ui.small(reason);
}
});
});
app.viewport.rect = Some(canvas);
return;
};
if !host {
crate::ui_kit::Container::navigation_contents(ui, |ui| result_header(app, ui));
}
// Widget growth cannot enlarge the reserved image/navigation canvas.
let rect = ui.available_rect_before_wrap().intersect(free);
if rect.width() < 1.0 || rect.height() < 1.0 {
return;
}
let response = ui.allocate_rect(rect, Sense::click_and_drag());
app.viewport.rect = Some(rect);
crate::viewport::refresh_layout(app, ui.ctx());
let size = [info.width, info.height];
let scale = app.render_workspace.view.result_scale;
if !host && scale != ResultScale::Free {
app.render_workspace.view.result_camera = result_camera(size, rect, ui.ctx().pixels_per_point(), scale);
}
if host {
app.render_workspace.result_navigation = Some((rect, response, false));
} else {
with_result_camera(app, |app| {
crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps { orbit: false, pick: false });
});
}
let after = app.render_workspace.view.result_scale;
if !host && after != scale && after != ResultScale::Free {
app.render_workspace.view.result_camera = result_camera(size, rect, ui.ctx().pixels_per_point(), after);
}
let camera = app.render_workspace.view.result_camera;
let mut image_rect = result_rect(camera, size, rect);
if after == ResultScale::Actual {
let dpi = ui.ctx().pixels_per_point();
let min = egui::pos2((image_rect.min.x * dpi).round() / dpi, (image_rect.min.y * dpi).round() / dpi);
image_rect = image_rect.translate(min - image_rect.min);
}
let painter = ui.painter().with_clip_rect(rect.intersect(ui.clip_rect()));
let visible = image_rect.intersect(rect);
if visible.is_positive() {
// Bound checker work by the visible canvas, even for an extremely magnified image.
painter.rect_filled(visible, 0.0, t.panel);
let cell = 24.0f32.max(visible.width().max(visible.height()) / 128.0);
for row in 0..(visible.height() / cell).ceil() as u32 {
for column in 0..(visible.width() / cell).ceil() as u32 {
if (row + column) % 2 == 0 {
let square = egui::Rect::from_min_size(visible.min + egui::vec2(column as f32 * cell, row as f32 * cell), egui::vec2(cell, cell));
painter.rect_filled(square.intersect(visible), 0.0, t.control_fill);
}
}
}
if let Some(display) = displayed_image(app)
&& let Ok(texture) = display.image
{
let source = displayed::Source::image(display.info, display.preview);
painter.image(texture.id(), image_rect, egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), Tokens::get().file_image_tint);
app.render_workspace.displayed.record(&painter, image_rect, source);
}
painter.rect_stroke(image_rect, 0.0, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Outside);
}
if !host {
let percent = f64::from(rect.height() * ui.ctx().pixels_per_point()) / (2.0 * camera.half_height()) * 100.0;
let label = painter.layout_no_wrap(format!("{percent:.1}%"), egui::FontId::proportional(t.font_label), t.text);
let badge = egui::Rect::from_min_size(
rect.left_bottom() + egui::vec2(t.space_8, -label.size().y - t.space_8 * 2.0),
label.size() + egui::vec2(t.space_8 * 2.0, t.space_8),
);
painter.rect_filled(badge, t.control_radius, t.panel);
painter.galley(badge.min + egui::vec2(t.space_8, t.space_8 * 0.5), label, t.text);
}
if !app.universal_panel_host_enabled() {
crate::navigation_bar_view::show(app, ui, rect);
}
}
/// What the product scene is extracted from: the document (appearances, the history marker),
/// the world state (geometry and placements) and what decides which bodies are visible. Not the
/// session's revision, which every command moves: a selection or a view change extracts no scene
/// and builds no vertices. The document and world state are held while the signature names them.
fn preview_signature(app: &mut SolveApp) -> (u64, usize, u64) {
let mut visibility = std::collections::hash_map::DefaultHasher::new();
let v = &app.session.visibility;
(&v.hidden_bodies, &v.hidden_occurrences, &v.hidden_folders, app.session.active_sketch).hash(&mut visibility);
let (doc, world) = (app.session.doc.clone(), crate::open_meshing::session_world(&app.session));
let signature = (Arc::as_ptr(&doc) as usize as u64, Arc::as_ptr(&world) as usize, visibility.finish());
app.render_workspace.scene_sources = Some((doc, world));
signature
}
pub(super) fn adaptive_preview_label(_app: &SolveApp, progress: solidcraft_engine::render::job::adaptive::AdaptivePreview) -> String {
use solidcraft_engine::render::job::adaptive::PreviewStage;
crate::i18n::format(
match progress.stage {
PreviewStage::Pilot => "render.adaptive.pilot_progress",
PreviewStage::Production => "render.adaptive.production_progress",
},
&[("current", &progress.completed.to_string()), ("target", &progress.target.to_string())],
)
}
impl State {
fn prepare_preview(&mut self, signature: (u64, usize, u64, u64), capture: impl FnOnce() -> Result<ProductScene, String>) -> Result<(), String> {
if self.scene_signature != Some(signature) {
let prepared = capture().and_then(|scene| gpu_scene_with_budget(&scene, signature.3).map(|(key, gpu)| (scene, key, gpu)));
self.scene_signature = Some(signature);
match prepared {
Ok((scene, key, gpu)) => {
let bytes = gpu.pbr.len() + gpu.tris.len() + gpu.glass.len();
if self.key != Some(key) {
let uploaded = match self.slot.lock() {
Ok(mut slot) => {
*slot = Some(gpu);
true
}
Err(_) => false,
};
if !uploaded {
let error = crate::i18n::tr("render.error_upload_slot").to_string();
self.scene = None;
self.key = None;
self.preview_upload_bytes = None;
self.scene_error = Some(error.clone());
return Err(error);
}
self.key = Some(key);
if let Ok(mut error) = self.upload_error.lock() {
*error = None;
}
}
self.scene = Some(scene);
self.scene_error = None;
self.preview_upload_bytes = Some(bytes);
}
Err(error) => {
self.scene = None;
self.key = None;
self.preview_upload_bytes = None;
if let Ok(mut slot) = self.slot.lock() {
*slot = None;
}
self.scene_error = Some(error);
}
}
}
match &self.scene_error {
Some(error) => Err(error.clone()),
None => Ok(()),
}
}
}
/// Use the shared kit's wrapped, themed error surface, not text painted directly
/// on the user-selected background (which may have the opposite theme contrast).
fn preview_error(app: &mut SolveApp, ui: &mut egui::Ui, rect: egui::Rect, error: &str) {
let t = Tokens::get();
let bounded = crate::shell::workspace_content(app, crate::shell::panel_bounds(app, rect)).shrink(t.space_12);
// At tiny window sizes the shell may leave no room for the shared error card.
if !bounded.is_finite() || bounded.width() < t.control_height + 2.0 * t.space_8 || bounded.height() < t.control_height + 2.0 * t.space_8 {
return;
}
ui.scope_builder(egui::UiBuilder::new().max_rect(bounded), |ui| {
ui.set_clip_rect(ui.clip_rect().intersect(bounded));
ui.set_max_width(bounded.width().min(t.form_card_width * 2.0));
crate::ui_kit::Panel::feature_frame(ui.ctx(), crate::shell::LayoutMode::Floating, crate::frame::Side::Left).inner_margin(t.space_8).show(
ui,
|ui| {
crate::ui_kit::text(ui, error, crate::ui_kit::Text::Error("render.preview_failure"));
crate::ui_kit::text(ui, app.tr("render.preview_unavailable_help"), crate::ui_kit::Text::Note("render.preview_unavailable_help"));
let retry = crate::ui_kit::button(ui, app.tr("render.preview_retry"), crate::ui_kit::Button::Normal);
crate::scenario::publish_target("render:preview-retry", retry.rect);
if retry.clicked() {
invalidate_scene(app);
ui.ctx().request_repaint();
}
},
);
});
}
/// Keep the selected image and overwrite consent fixed while the upstream picker holds model input.
fn export_image(app: &mut SolveApp, job: solidcraft_engine::render::job::JobId, overwrite: bool) {
let origin = app.session.doc.clone();
app.pick_save("render.png", &["png"], move |app, path| {
let Some(path) = path else { return };
if !Arc::ptr_eq(&origin, &app.session.doc) {
app.set_status(crate::i18n::tr("render.error_export_document"), true);
return;
}
let _ = app.run("render.export", json!({"job":job,"path":path,"overwrite":overwrite}));
});
}
/// Captures format and completed identity before the asynchronous picker opens.
fn export_linear_image(app: &mut SolveApp, job: solidcraft_engine::render::job::JobId, overwrite: bool) {
let origin = app.session.doc.clone();
app.pick_save("render.exr", &["exr"], move |app, path| {
let Some(path) = path else {
return;
};
if !Arc::ptr_eq(&origin, &app.session.doc) {
app.set_status(crate::i18n::tr("render.error_export_document"), true);
return;
}
let _ = app.run("render.export", json!({"job":job,"path":path,"overwrite":overwrite,"format":"exr"}));
});
}
/// An exact expanded vertex payload, counted before allocating its buffers.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct PreviewUploadPlan {
pbr: usize,
tris: usize,
glass: usize,
source_triangles: usize,
}
impl PreviewUploadPlan {
fn bytes(self) -> Result<usize, String> {
self.pbr.checked_add(self.tris).and_then(|n| n.checked_add(self.glass)).ok_or_else(|| crate::i18n::tr("render.error_geometry_size").into())
}
fn add(&mut self, pbr: bool, glass: bool, triangles: usize, limit: usize) -> Result<(), String> {
let stride = if pbr { crate::gpu::PBR_SIZE } else { crate::gpu::TRI_SIZE };
let bytes = triangles.checked_mul(3).and_then(|n| n.checked_mul(stride)).ok_or(crate::i18n::tr("render.error_geometry_size"))?;
let count = if pbr {
&mut self.pbr
} else if glass {
&mut self.glass
} else {
&mut self.tris
};
*count = count.checked_add(bytes).ok_or(crate::i18n::tr("render.error_geometry_size"))?;
admit_geometry(self.bytes()? as u64, limit as u64)
}
}
fn preview_upload_plan(scene: &ProductScene, limit: usize) -> Result<PreviewUploadPlan, String> {
if scene.meshes.len() > solidcraft_engine::render::job::MAX_CPU_BODIES {
return Err(crate::i18n::tr("render.error_body_bound").into());
}
let mut plan = PreviewUploadPlan::default();
for body in &scene.meshes {
plan.source_triangles = plan.source_triangles.checked_add(body.mesh.triangles.len()).ok_or(crate::i18n::tr("render.error_triangle_count"))?;
if plan.source_triangles > solidcraft_engine::render::job::MAX_CPU_TRIANGLES {
return Err(crate::i18n::tr("render.error_triangle_bound").into());
}
if body.faces.len() > 262_144 {
return Err(crate::i18n::tr("render.error_face_cap").into());
}
if !body.opacity.is_finite()
|| !(0.0..=1.0).contains(&body.opacity)
|| body.faces.iter().any(|face| !face.opacity.is_finite() || !(0.0..=1.0).contains(&face.opacity))
{
return Err(crate::i18n::tr("render.error_opacity").into());
}
let looks: std::collections::BTreeMap<_, _> = body.faces.iter().map(|face| (face.face, face)).collect();
if looks.len() != body.faces.len() {
return Err(crate::i18n::tr("render.error_duplicate_face").into());
}
for index in 0..body.mesh.triangles.len() {
let face = body.mesh.tri_face.get(index).and_then(|id| looks.get(id));
let (opacity, pbr) = face.map_or((body.opacity, body.surface.is_some() && body.transmission.is_none()), |face| {
(face.opacity, face.surface.is_some() && face.transmission.is_none())
});
if pbr && opacity != 1.0 {
return Err(crate::i18n::tr("render.error_pbr_opacity").into());
}
if opacity > 0.0 {
plan.add(pbr, opacity < 0.999, 1, usize::MAX)?;
}
}
}
admit_geometry(plan.bytes()? as u64, limit as u64)?;
Ok(plan)
}
/// Convert all captured surfaces, without decimation. The finite, exact payload
/// plan is admitted first; each output vector is reserved once rather than grown
/// once per triangle. Device uploads retain their existing chunked buffer path.
#[cfg(test)]
fn gpu_scene(scene: &ProductScene) -> Result<(u64, GpuScene), String> {
gpu_scene_with_budget(scene, MAX_GEOMETRY_BYTES as u64)
}
fn gpu_scene_with_budget(scene: &ProductScene, budget: u64) -> Result<(u64, GpuScene), String> {
let limit = usize::try_from(budget).unwrap_or(usize::MAX);
let plan = preview_upload_plan(scene, limit)?;
let mut hash = std::collections::hash_map::DefaultHasher::new();
let mut gpu = GpuScene::default();
for (buffer, bytes) in [(&mut gpu.pbr, plan.pbr), (&mut gpu.tris, plan.tris), (&mut gpu.glass, plan.glass)] {
buffer.try_reserve_exact(bytes).map_err(|_| crate::i18n::tr("render.error_vertex_allocation").to_string())?;
}
for body in &scene.meshes {
if body.faces.len() > 262_144 {
return Err(crate::i18n::tr("render.error_face_cap").into());
}
if !body.opacity.is_finite()
|| !(0.0..=1.0).contains(&body.opacity)
|| body.faces.iter().any(|f| !f.opacity.is_finite() || !(0.0..=1.0).contains(&f.opacity))
{
return Err(crate::i18n::tr("render.error_opacity").into());
}
(Arc::as_ptr(&body.mesh) as usize).hash(&mut hash);
body.name.hash(&mut hash);
body.color.hash(&mut hash);
body.opacity.to_bits().hash(&mut hash);
body.transmission.is_some().hash(&mut hash);
hash_surface(body.surface, &mut hash);
let looks: std::collections::BTreeMap<_, _> = body.faces.iter().map(|l| (l.face, l)).collect();
for face in &body.faces {
face.face.hash(&mut hash);
face.color.hash(&mut hash);
face.opacity.to_bits().hash(&mut hash);
face.transmission.is_some().hash(&mut hash);
hash_surface(face.surface, &mut hash);
}
for (index, triangle) in body.mesh.triangles.iter().enumerate() {
let face = body.mesh.tri_face.get(index).and_then(|f| looks.get(f));
let (color, opacity, surface) = face.map_or((body.color, body.opacity, body.surface.filter(|_| body.transmission.is_none())), |l| {
(l.color, l.opacity, l.surface.filter(|_| l.transmission.is_none()))
});
if surface.is_some() && opacity != 1.0 {
return Err(crate::i18n::tr("render.error_pbr_opacity").into());
}
if opacity <= 0.0 {
continue;
}
let vertices = triangle.map(|i| {
let p = body.mesh.positions.get(i as usize)?.to_f32();
let n = *body.mesh.normals.get(i as usize)?;
let n = if surface.is_some() { solidcraft_engine::render::surface::unit_direction(n).ok()? } else { n }.to_f32();
p.into_iter().chain(n).all(f32::is_finite).then_some((p, n))
});
let [Some(a), Some(b), Some(c)] = vertices else {
return Err(crate::i18n::tr("render.error_product_triangle").into());
};
let rgba = [color[0], color[1], color[2], (opacity * 255.0).round() as u8];
let index = gpu.color(rgba);
for (p, n) in [a, b, c] {
if let Some(surface) = surface {
if n.iter().all(|v| *v == 0.0) {
return Err(crate::i18n::tr("render.error_surface_normals").into());
}
gpu.pbr_tri(p, n, surface);
} else if opacity < 0.999 {
gpu.glass_tri(p, n, index);
} else {
gpu.tri(p, n, index);
}
}
}
}
if (gpu.pbr.len(), gpu.tris.len(), gpu.glass.len()) != (plan.pbr, plan.tris, plan.glass) {
return Err(crate::i18n::tr("render.error_vertex_packing").into());
}
Ok((hash.finish(), gpu))
}
fn hash_surface(surface: Option<solidcraft_engine::render::surface::OpaqueSurface>, hash: &mut impl Hasher) {
surface.is_some().hash(hash);
if let Some(s) = surface {
let c = s.base_color();
for value in [c.x, c.y, c.z, s.metallic(), s.roughness(), s.dielectric_ior()] {
value.to_bits().hash(hash);
}
}
}
/// The image's width over its height.
pub fn image_aspect(setup: &RenderSetup) -> f64 {
f64::from(setup.width.max(1)) / f64::from(setup.height.max(1))
}
/// Product Fit/navigation use the actual output-camera frame in every inspector.
/// Contextual guide visibility is independent; the compatibility preference keeps
/// its previous Frame-only projection policy.
pub(crate) fn camera_rect(app: &SolveApp, supplied: egui::Rect) -> egui::Rect {
if app.viewport.rect != Some(supplied) {
return supplied;
}
authored_camera_rect(app, supplied)
}
/// Resolve the painted projection from an authoritative outer product canvas.
fn authored_camera_rect(app: &SolveApp, supplied: egui::Rect) -> egui::Rect {
if !active(app) || app.preferences.render_legacy_image_defaults || app.render_workspace.view.result || app.render_workspace.view.compare.is_some()
{
return supplied;
}
live::projection_rect(app, shot::render_rect(app, supplied))
}
pub(crate) fn picture_layout(app: &SolveApp, layout: &crate::viewport_layout::Layout) -> crate::viewport_layout::Layout {
let frame = if app.preferences.render_legacy_image_defaults {
live::projection_rect(app, shot::render_rect(app, layout.viewport))
} else {
camera_rect(app, layout.viewport)
};
if frame == layout.viewport {
return layout.clone();
}
// The same 16-point margin the viewport's fit keeps inside its free area.
crate::viewport_layout::Layout {
viewport: frame,
drawable: layout.drawable.intersect(frame.shrink(16.0)),
middle: layout.middle.intersect(frame),
..layout.clone()
}
}
/// Clip the current host obstacles to the painted product projection.
pub(crate) fn host_picture_layout(
app: &SolveApp,
layout: &crate::viewport_layout::Layout,
usable: &crate::panel_runtime::HostUsableRegion,
) -> Option<crate::viewport_layout::Layout> {
let picture = if app.preferences.render_legacy_image_defaults {
shot::preview_rect(app, layout.viewport).unwrap_or(layout.viewport)
} else {
authored_camera_rect(app, layout.viewport)
};
crate::viewport_layout::host_projection_layout(layout, usable, picture)
}
/// Explicit product Fit shares the host fitter but keeps Render's authored lens
/// and existing full-size Fit policy. Layout changes never call this helper.
pub(crate) fn fit_host_product_bounds(
app: &SolveApp,
cam: Camera,
bounds: &solidcraft_engine::geom::Aabb3,
layout: &crate::viewport_layout::Layout,
usable: &crate::panel_runtime::HostUsableRegion,
) -> Option<Camera> {
let picture = host_picture_layout(app, layout, usable)?;
crate::viewport_layout::fit_host_bounds(cam, bounds, &picture, picture.usable.as_ref()?, cam.fov, 1.0)
}
/// Look At/Centre uses the same picture and authored FOV while preserving the
/// requested focus and distance contract of the shared centring implementation.
pub(crate) fn centre_host_product_camera(
app: &SolveApp,
cam: Camera,
bounds: Option<&solidcraft_engine::geom::Aabb3>,
layout: &crate::viewport_layout::Layout,
usable: &crate::panel_runtime::HostUsableRegion,
) -> Option<Camera> {
let picture = host_picture_layout(app, layout, usable)?;
crate::viewport_layout::centre_host_camera(cam, bounds, &picture, picture.usable.as_ref()?, cam.fov)
}
/// The size the product preview draws at for a viewport of `full` physical pixels: the full
/// size when the viewport executor admits it, else the largest size at the same aspect it does.
/// Without an executor the request is left for resolution to report.
pub fn preview_size(executor: Option<&ExecutorDescriptor>, full: (u64, u64)) -> (u64, u64) {
executor.and_then(|e| e.fit(full.0, full.1)).unwrap_or(full)
}
/// Theme only the untouched, unsaved preview. Saved setups have no background provenance,
/// so even a saved default-colour backplate remains scene-owned. Never alter image requests.
fn preview_background(app: &SolveApp) -> Tokens {
let view = &app.render_workspace.view;
let tokens = Tokens::get();
if crate::theme::tab_surfaces_enabled()
&& !app.session.doc.render.setups.contains_key(&view.name)
&& view.clean_setup.as_ref().is_some_and(|clean| clean.background == view.draft.background)
&& !view.transparent
&& !view.studio.backdrop_enabled
&& view.studio.environment == studio::Environment::None
&& view.cpu.environment == cpu::Environment::None
&& view.raytrace.environment.is_none()
{
// Includes the current fade and explicit viewport palette/flat-colour preferences.
tokens
} else {
tokens.with_background(Some(view.draft.background))
}
}
pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
app.render_workspace.result_navigation = None;
if app.render_workspace.view.compare.is_some() {
app.render_workspace.view.environment_ring = environment::RingView::default();
assign::stop(app);
compare::show(app, ui);
return;
}
if app.render_workspace.view.result {
app.render_workspace.view.environment_ring = environment::RingView::default();
assign::stop(app);
show_result(app, ui);
return;
}
let viewport = ui.max_rect();
app.viewport.rect = Some(viewport);
// Framing uses the output camera's own aspect, including navigation and picking.
let rect = live::projection_rect(app, shot::render_rect(app, viewport));
crate::scenario::publish_rect("render:product:frame", rect);
crate::viewport::refresh_layout(app, ui.ctx());
// Gray letterbox remains an ordinary navigation surface. Geometry assignment
// and selection are separately limited to the actual image camera below.
let input_rect = if app.preferences.render_legacy_image_defaults { rect } else { viewport };
let response = ui.interact(input_rect, ui.scope_id().with("render_preview"), Sense::click_and_drag());
let geometry_current = live::picking_current(app);
if !environment::ring_input(app, ui, rect, &response) {
let input = crate::navigation::handle(app, ui, input_rect, &response, crate::navigation::NavCaps::RENDER);
let image_inside = input.inside && input.hover.is_some_and(|point| rect.contains(point));
let navigating = input.scroll != 0.0
|| input.pinch != 1.0
|| input.pan != egui::Vec2::ZERO
|| input.middle
|| input.secondary_down
|| (input.primary_nav.is_some() && input.primary_down)
|| input.mode.is_some()
|| app.viewport.axis_drag.is_some()
|| app.viewport.spin
|| app.cam_anim.is_some();
let hits = input
.hover
.filter(|_| image_inside && !navigating && geometry_current)
.map(|p| crate::viewport::pick_cached(app, &crate::viewport::projection(app, rect), p))
.unwrap_or_default();
let candidate = assign::candidate(app, &hits, input.mods);
app.viewport.hover = candidate.as_ref().map(|(hit, _)| hit.clone());
let assigning = assign::input(app, ui, &response, candidate.as_ref(), image_inside && !navigating && geometry_current);
if !assigning && image_inside && !navigating {
assign::hover_tooltip(app, &response, candidate.as_ref());
}
if !assigning && response.clicked_by(egui::PointerButton::Primary) && image_inside && !navigating && geometry_current {
let (add, toggle) = crate::tool_modifiers::selection_click(
crate::tool_modifiers::Held::from_modifiers(input.mods),
app.preferences.selection_shift_add_only,
);
crate::viewport::select(app, candidate.as_ref().map(|(_, sel)| sel.clone()), add, toggle);
}
if response.secondary_clicked()
&& let Some((crate::viewport::Hit::Face { body, .. }, _)) = &candidate
{
if let Some(candidate) = &candidate {
assign::context(app, candidate);
}
crate::context_menu::open_for(app, input.hover.unwrap_or(rect.center()), crate::context_menu::Target::Body { name: body.clone() });
}
} else {
app.viewport.hover = None;
}
crate::gpu::paint_background(ui.painter(), viewport, &preview_background(app));
if live::has_picture(app) {
live::paint(app, ui, rect);
if live::picking_current(app) {
paint_product_feedback(app, ui, rect, app.cam);
}
} else {
paint_product(app, ui, rect, app.cam, None);
}
shot::overlay(app, ui, viewport);
if !app.universal_panel_host_enabled() {
crate::viewport::axis_view(app, ui, viewport);
crate::navigation_bar_view::show(app, ui, viewport);
}
}
fn product_projection(camera: Camera, radius: f64, canvas: egui::Rect, image: Option<egui::Rect>) -> solidcraft_engine::render::Mat4 {
let image = image.unwrap_or(canvas);
let projection = camera.view_proj(f64::from(image.width() / image.height().max(1.0)), radius);
let sx = f64::from(image.width() / canvas.width().max(1.0));
let sy = f64::from(image.height() / canvas.height().max(1.0));
let tx = f64::from(2.0 * (image.center().x - canvas.center().x) / canvas.width().max(1.0));
let ty = f64::from(2.0 * (canvas.center().y - image.center().y) / canvas.height().max(1.0));
solidcraft_engine::render::Mat4([[sx, 0.0, 0.0, 0.0], [0.0, sy, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [tx, ty, 0.0, 1.0]]).mul(&projection)
}
fn paint_product(app: &mut SolveApp, ui: &mut egui::Ui, rect: egui::Rect, camera: Camera, image: Option<egui::Rect>) {
paint_product_kind(app, ui, rect, camera, image, false);
}
fn paint_product_feedback(app: &mut SolveApp, ui: &mut egui::Ui, rect: egui::Rect, camera: Camera) {
paint_product_kind(app, ui, rect, camera, None, true);
}
fn paint_product_kind(app: &mut SolveApp, ui: &mut egui::Ui, rect: egui::Rect, camera: Camera, image: Option<egui::Rect>, feedback: bool) {
let background = preview_background(app);
if !feedback {
crate::gpu::paint_background(ui.painter(), rect, &background);
}
let result = (|| -> Result<(), String> {
if app.viewport.gpu.is_none() {
return Err(crate::i18n::tr("render.error_gpu_preview").into());
}
let ppp = ui.ctx().pixels_per_point();
let setup = &app.render_workspace.view.draft;
if !feedback
&& ((app.render_workspace.view.method == ImageMethod::Raster && setup.exposure_ev != 0.0)
|| setup.environment_rotation != 0.0
|| setup.environment_intensity != 1.0)
{
return Err(crate::i18n::tr("render.error_fixed_preview").into());
}
// A 4K or 5K viewport is past the preview's pixel budget: draw it smaller and filter it
// up into the viewport rather than refusing the frame.
let full = ((rect.width() * ppp).max(1.0) as u64, (rect.height() * ppp).max(1.0) as u64);
let (width, height) = preview_size(app.session.render_viewport(), full);
let mut request = RenderRequest {
backend: Some(setup.backend.clone()),
mode: setup.mode,
operation: RenderOperation::Viewport,
width,
height,
format: None,
features: Vec::new(),
policy: Default::default(),
};
solidcraft_engine::render::resolve_request(&[app.session.render_backend()], &request).map_err(|e| e.to_string())?;
if app.session.model.is_stale() {
return Err(crate::i18n::tr("render.error_finish_gesture").into());
}
let (doc, world, visibility) = preview_signature(app);
let budget = preferred_geometry_budget(app.render_workspace.geometry_budget, app.preferences.render_previous_geometry_budget);
let signature = (doc, world, visibility ^ assign::preview_key(app), budget);
let preview = assign::preview(app);
let previous_key = app.render_workspace.key;
app.render_workspace.prepare_preview(signature, || {
let mut scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|error| error.to_string())?;
assign::preview_scene(&mut scene, preview.as_ref())?;
Ok(scene)
})?;
if app.render_workspace.key != previous_key {
ui.ctx().request_repaint();
}
let scene = app.render_workspace.scene.as_ref().ok_or(crate::i18n::tr("render.error_no_scene"))?;
if let Some(error) = app.render_workspace.upload_error.lock().ok().and_then(|e| e.clone()) {
return Err(upload_refusal(app.render_workspace.preview_upload_bytes.unwrap_or(0) as u64, &error));
}
request.features = scene.required_features();
solidcraft_engine::render::resolve_request(&[app.session.render_backend()], &request).map_err(|e| e.to_string())?;
let key = app.render_workspace.key.ok_or(crate::i18n::tr("render.error_no_geometry"))?;
if scene.bounds.is_empty() {
return Err(crate::i18n::tr("render.error_visible_solid").into());
}
let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(camera.target);
let eye = camera.eye();
let highlight_key = crate::viewport::highlight_key(app);
if highlight_key != app.viewport.hl_key {
let overlay = crate::viewport::build_highlight(app);
if let Ok(mut slot) = app.viewport.hl_slot.lock() {
*slot = Some(overlay);
}
app.viewport.hl_key = highlight_key;
}
let slot = app.render_workspace.slot.clone();
let frame = Frame {
product_lights: if feedback { None } else { Some(light::preview(app)?) },
product: true,
upload_error: Some(app.render_workspace.upload_error.clone()),
key,
slot: slot.clone(),
sketch_key: 0,
sketch_slot: slot.clone(),
hl_key: app.viewport.hl_key,
hl_slot: app.viewport.hl_slot.clone(),
pv_key: 0,
pv_slot: slot,
pv_hide: false,
preview_bounds: None,
view_proj: product_projection(camera, radius, rect, image).to_f32(),
back: camera.back().to_f32(),
size_px: [rect.width() * ppp, rect.height() * ppp],
clip: [0.0; 4],
cap: [0.0; 4],
images: Vec::new(),
clouds: Vec::new(),
analysis: [0.0; 8],
analysis_colors: [0.0; 36],
access: None,
outline: false,
// Product rendering has its own lighting; AO is a Design viewport setting.
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
sky: [0.0; 4],
eye: [eye.x as f32, eye.y as f32, eye.z as f32, if camera.fov > 0.0 { 1.0 } else { 0.0 }],
ssaa: if width < full.0 { width as f32 / full.0 as f32 } else { 1.0 },
hover_tint: [f32::from(Tokens::get().hover_face_lift) / 255.0; 3],
selection_tint: {
let c = Tokens::get().body_selected;
[f32::from(c.r()) / 255.0, f32::from(c.g()) / 255.0, f32::from(c.b()) / 255.0]
},
hatch: Default::default(),
moving: None,
};
if feedback {
ui.painter().add(egui_wgpu::Callback::new_paint_callback(rect, crate::gpu::ProductHighlightCallback(frame)));
} else {
crate::blur::viewport(ui.painter(), rect, ViewportCallback(frame), rect, [background.viewport_top, background.viewport_bottom]);
}
Ok(())
})();
if let Err(error) = result {
preview_error(app, ui, rect, &error);
}
}
/// Apply validated UI requests after the same registry call used by automation.
pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::Value) -> Result<(), String> {
if matches!(id, "render.result.view" | "render.result.close" | "render.result.select" | "render.result.discard" | "render.compare") {
app.render_workspace.displayed.clear();
}
if matches!(
id,
"render.start"
| "render.batch"
| "render.result.regrade"
| "render.result.view"
| "render.result.close"
| "render.result.select"
| "render.result.discard"
| "render.result.pin"
| "render.compare"
) {
app.render_workspace.view.auto_result_job = None;
}
match id {
"render.preflight.copy" => {
app.render_workspace.clipboard_text = Some(reply["text"].as_str().ok_or("invalid check report")?.to_string());
}
"render.compare" => compare::apply(app, reply)?,
"render.compare.divider" => {
let position = reply["position"].as_f64().ok_or("invalid comparison divider position")?;
if let Some(view) = &mut app.render_workspace.view.compare {
view.position = crate::ui_kit::comparison_position(position as f32);
}
}
"render.batch" => follow_batch(app),
"render.start" | "render.result.regrade" => {
let job = serde_json::from_value(reply["job"].clone()).map_err(|e| format!("invalid render job identity: {e}"))?;
let shot = if id == "render.result.regrade" {
app.render_workspace
.view
.retained
.iter()
.find(|result| Some(result.frame.job) == app.render_workspace.view.completed)
.and_then(|result| result.shot.clone())
} else {
Some(app.render_workspace.view.name.clone())
};
if let Some(shot) = &shot {
let _ = app.session.label_render_job(job, shot);
}
app.render_workspace.view.job = Some(job);
app.render_workspace.view.job_shot = shot;
app.render_workspace.view.follow_job = app.render_workspace.view.compare.is_none();
}
"render.result.select" | "render.result.discard" | "render.result.pin" => {
sync_results(app);
app.render_workspace.preview_image = None;
app.render_workspace.view.follow_job = false;
if matches!(id, "render.result.select" | "render.result.pin") {
app.render_workspace.view.compare = None;
app.render_workspace.comparison_images.clear();
}
if id == "render.result.select" {
app.render_workspace.view.result = true;
}
}
"render.output.size" => {
let width = reply["width"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output width")?;
let height = reply["height"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output height")?;
if cpu::image_limits(app).fit(u64::from(width), u64::from(height), None) != Some((u64::from(width), u64::from(height))) {
return Err(app.tr("render.output_over_budget").into());
}
app.render_workspace.view.inspector.resolution.custom = reply["custom"].as_bool().unwrap_or(false);
app.render_workspace.view.draft.width = width;
app.render_workspace.view.draft.height = height;
app.render_workspace.view.dirty = true;
}
"render.result.view" | "render.result.close" => {
let view = reply["view"].as_str().ok_or("invalid result view")?;
if view == "actual" && reduced_display(app) {
return Err(app.tr("render.result_reduced_display").into());
}
app.render_workspace.view.result = view != "model";
if matches!(view, "model") || id == "render.result.close" {
app.render_workspace.view.compare = None;
app.render_workspace.comparison_images.clear();
}
match view {
"fit" => fit_result(app),
"actual" => {
app.render_workspace.view.result_scale = ResultScale::Actual;
app.render_workspace.view.result_domain = None;
}
_ => {}
}
app.cancel_view_animation();
app.viewport.nav = None;
app.viewport.key_hold = None;
app.viewport.orbit_free = None;
}
"render.result.copy" => {
let job = serde_json::from_value(reply["frame"]["job"].clone()).map_err(|e| e.to_string())?;
let frame = app
.session
.render_job_handle(job)
.map_err(|e| e.to_string())?
.frame()
.map_err(|e| e.to_string())?
.ok_or_else(|| app.tr("render.ribbon_no_result").to_string())?;
let image = decode_render_image(frame.png(), frame.info.width, frame.info.height, RenderLimits::default(), 4096)?;
app.render_workspace.clipboard_image = Some(image);
}
_ => {}
}
Ok(())
}
/// GPU setup has no driver progress fraction. Keep its temporary window separate
/// from the render progress row and retire it as soon as preparation ends.
pub(crate) fn show_shader_preparation(app: &mut SolveApp, ctx: &egui::Context) -> bool {
use solidcraft_engine::render::job::Phase;
let Some(handle) = app.render_workspace.view.job.and_then(|job| app.session.render_job_handle(job).ok()) else {
return false;
};
let Ok(status) = handle.status() else { return false };
if status.progress.phase != Phase::Preparing || status.resolved.executor.as_str() != "gpu-path" {
return false;
}
let mut cancel = false;
crate::ui_kit::Window::new(egui::Id::unique("render_shader_preparation"), "", app.tr("render.image_preparing")).show_passive_body(ctx, |ui| {
let warning = ui.label(app.tr("render.gpu_job_shader_wait"));
crate::scenario::publish_rect("render:shader-preparation:warning", warning.rect);
ui.horizontal(|ui| {
let spinner = ui.spinner();
crate::scenario::publish_rect("render:shader-preparation:spinner", spinner.rect);
ui.label(mmss(handle.elapsed()));
});
let button = crate::ui_kit::button(ui, app.tr("cmd.render_cancel"), crate::ui_kit::Button::Normal);
crate::scenario::publish_target("render:shader-preparation:cancel", button.rect);
cancel = button.clicked();
});
if cancel && let Err(error) = app.run("render.cancel", json!({"job": handle.id()})) {
app.set_status(error, true);
}
ctx.request_repaint_after(std::time::Duration::from_millis(100));
true
}
/// `key` names the row's scenario handles (`ui_kit::progress_action`).
pub(crate) fn progress_pill(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) -> bool {
if prepare::progress(app, ui) {
return true;
}
if live::final_pending(app) {
crate::ui_kit::text(ui, app.tr("render.live.final_waiting"), crate::ui_kit::Text::Inline);
let cancel = crate::ui_kit::button(ui, app.tr("cmd.render_cancel"), crate::ui_kit::Button::Normal);
crate::scenario::publish_target("render:progress-cancel", cancel.rect);
if cancel.clicked() {
app.start("render.cancel");
}
return true;
}
if !ribbon::busy(app) {
return false;
}
let Some(job) = app.render_workspace.view.job else {
return false;
};
let Ok(status) = app.session.execute("render.status", &json!({"job":job})) else {
return false;
};
let phase = status["progress"]["phase"].as_str().unwrap_or("unknown");
if !matches!(phase, "queued" | "preparing" | "running" | "encoding" | "cancelling") {
return false;
}
let done = status["progress"]["done"].as_u64().unwrap_or(0);
let total = status["progress"]["total"].as_u64().unwrap_or(1).max(1);
let fraction = (done as f64 / total as f64).clamp(0.0, 1.0) as f32;
let phase_key = format!("render.image_{phase}");
let name = app.render_workspace.view.job_shot.as_ref().unwrap_or(&app.render_workspace.view.name).clone();
let message = format!("· {} · {:.0}%", app.tr(&phase_key), fraction * 100.0);
let cancel = crate::ui_kit::progress_action(ui, key, &name, &message, fraction, app.tr_label("Cancel"));
crate::scenario::publish_target("render:progress-cancel", cancel.rect);
if cancel.clicked() {
app.start("render.cancel");
}
ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
true
}
pub(crate) fn environment_overlay(app: &mut SolveApp, ui: &mut egui::Ui, viewport: egui::Rect) {
environment::ring_overlay(app, ui, viewport);
}
pub(crate) fn interactive_command_info(app: &SolveApp, command: &solidcraft_engine::CommandSpec) -> solidcraft_engine::CommandInfo {
let mut info = ribbon::command_info(app, command);
if let Some(action) = solidcraft_engine::panels::ContextualPanelAction::from_command_id(command.id) {
info.disabled_reason = app.panel_contextual_disabled_reason(action);
info.enabled = info.disabled_reason.is_none();
return info;
}
// A drawing tool on the SKETCH tab kept shown outside a sketch starts one (#7904).
if crate::workspace::starts_a_sketch(app, command.id) {
info.enabled = true;
info.disabled_reason = None;
}
info
}
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 {
assign::start(app, id) || ribbon::start(app, id)
}