Files
makeCAD/crates/ui-egui/src/render_workspace.rs
T
raykholo 884c47496b Render preview: geometry budget from the device, readable refusals (#4127) (#4154)
* claim: #4127

* Render preview: geometry budget from the device, readable refusals (#4127)

The Render preview refused every scene over a fixed 128 MiB of geometry. On
desktop the budget now follows the device's buffer limit (eight of its
largest buffers, at most 2 GiB; 2 GiB with the usual 256 MiB buffers). The
web keeps 128 MiB.

The product upload runs under its own GPU error scopes: an allocation the
device refuses is reported in the preview instead of reaching the device's
uncaptured-error handler, and the half-uploaded batches are dropped. Buffer
uploads map the buffer themselves so a refused buffer fails the upload
rather than panicking in create_buffer_init.

Refusals name the geometry size and the limit and say how to get under it,
on a theme panel card that stays readable on any preview background.

* Render preview: keep the previous geometry budget behind a preference (#4127)

* Render preview: adapt the device budget to main's GPU upload errors (#4127)
2026-10-29 13:33:39 +00:00

2190 lines
94 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Integrated product preview. Shares the installed device/pipelines, not Design's scene policy.
use std::hash::{Hash, Hasher};
use std::sync::{Arc, Mutex};
use egui::{Color32, 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_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_inspector.rs"]
mod inspector;
#[path = "render_workspace_library.rs"]
mod library;
#[path = "render_ui/assign.rs"]
pub(crate) mod assign;
#[path = "render_workspace_light.rs"]
pub(crate) mod light;
#[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>,
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>,
pub view: ViewState,
revision: u64,
design_camera: Option<(Camera, bool)>,
slot: SceneSlot,
key: Option<u64>,
scene_signature: Option<(u64, usize, u64, u64)>,
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>,
}
/// Provisional pixels are never an export source and never replace the retained final image.
struct PreviewImage {
info: PreviewInfo,
image: Result<egui::TextureHandle, String>,
}
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 {
#[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",
}
}
fn page(self) -> inspector::Page {
match self {
Self::Look => inspector::Page::Appearance,
Self::Light => inspector::Page::Lighting,
Self::Frame => inspector::Page::Camera,
Self::Output => inspector::Page::Output,
}
}
}
/// Browser focus is transient per-document view state, never part of a saved design.
#[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,
}
/// Selection-driven homes introduced by E1/E7; remaining editors retain their adapters.
pub(crate) fn selection_editor(app: &mut SolveApp, selection: &RenderSelection) {
app.render_workspace.view.inspector.page = match selection {
RenderSelection::Nothing => inspector::Page::Scene,
RenderSelection::Shot(_) => inspector::Page::Camera,
RenderSelection::Output => inspector::Page::Output,
_ => return,
};
}
pub(crate) fn select_lighting(app: &mut SolveApp) {
app.render_workspace.view.inspector.page = inspector::Page::Lighting;
}
/// 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,
clean_setup: Option<RenderSetup>,
job: Option<solidcraft_engine::render::job::JobId>,
completed: Option<solidcraft_engine::render::job::JobId>,
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,
result_job: Option<solidcraft_engine::render::job::JobId>,
}
#[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,
clean_setup: None,
job: None,
completed: 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_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,
geometry_budget: WEB_GEOMETRY_BYTES,
upload_error: Arc::new(Mutex::new(None)),
image_host: None,
view: Default::default(),
revision: u64::MAX,
design_camera: None,
slot: Arc::new(Mutex::new(None)),
key: None,
scene_signature: None,
scene: None,
scene_error: None,
preview_upload_bytes: None,
image: None,
image_info: None,
preview_image: None,
clipboard_image: None,
clipboard_text: None,
}
}
}
impl State {
/// Retain the selected viewport adapter, but do not open another device or
/// compile shaders until Render is used. 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));
}
}
#[cfg(not(target_arch = "wasm32"))]
fn start_deferred_path_host(&mut self) {
if matches!(self.path_host, PathHost::NotStarted)
&& let Some(create) = self.pending_setup.take()
{
self.path_host.start(create);
}
}
}
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 fit_result(app: &mut SolveApp) {
app.render_workspace.view.result_scale = ResultScale::Fit;
}
/// 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,
"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,
},
})
}
pub fn sync_backend(app: &mut SolveApp) {
#[cfg(not(target_arch = "wasm32"))]
if active(app) {
app.render_workspace.start_deferred_path_host();
}
if let Some(took) = app.render_workspace.path_host.poll() {
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) {
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),
}
}
if app.render_workspace.view.job.is_some() {
cache_render_images(app, ctx);
}
}
pub fn reset_document(app: &mut SolveApp) {
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();
app.render_workspace = State { host, image_host, path_host, setup_seconds, setup_key, pending_setup, geometry_budget, ..Default::default() };
if active(app) {
app.ui.tab = "MODEL".into();
}
sync_backend(app);
}
pub(crate) fn invalidate_images(app: &mut SolveApp) {
app.render_workspace.image = None;
app.render_workspace.image_info = None;
app.render_workspace.preview_image = None;
}
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 = 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!({}))?;
if !active(app) {
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 scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|e| e.to_string())?;
if !scene.bounds.is_empty() {
app.fit_bounds(scene.bounds);
}
}
setups::refresh_dirty(app);
if app.render_workspace.revision != app.session.revision && !app.render_workspace.view.dirty {
setups::load(app);
}
#[cfg(not(target_arch = "wasm32"))]
app.render_workspace.start_deferred_path_host();
} else {
assign::stop(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 {
app.pending_fit = None;
}
Ok(())
}
/// 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;
app.render_workspace.view.inspector.page = stage.page();
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");
}
}
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(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.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 PathHost::Ready(host) = &app.render_workspace.path_host else {
return Err(app.tr("render.gpu_unavailable").to_string());
};
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::has_runtime_inputs(app) {
return Ok(json!({"settings":setups::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 settings = RenderSetup { camera: app.cam, job: None, ..view.draft.clone() };
let mut params = json!({"settings":settings,"transparent_background":view.transparent});
match view.method {
ImageMethod::Raster => {}
ImageMethod::CpuRaytrace => {
if view.transparent {
return Err(app.tr("render.cpu_opaque_required").to_string());
}
cpu::params(app, &mut params)?;
}
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 select_image_method(app: &mut SolveApp, method: ImageMethod) {
app.render_workspace.view.method = method;
// 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 response = crate::ui_kit::dropdown_menu(ui, "render_image_method", &label, |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.on_hover_text(reason);
}
}
});
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"));
}
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").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)))
.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());
}
_ => {}
}
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);
}
fn job_controls(app: &mut SolveApp, ui: &mut egui::Ui, compact: bool) {
let params = image_params(app);
if !compact {
if let Err(error) = &params {
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");
if phase == "completed" {
app.render_workspace.view.completed = Some(job);
}
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) = &params {
response.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()))
.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"))?;
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.session.execute("render.result.pin", &json!({"job":job})).map_err(|e| e.to_string())?;
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 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 || !(1..=4096).contains(&info.samples_per_pixel) {
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());
}
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())?;
let image = decode_render_image(
png,
info.frame.width,
info.frame.height,
captured_image_limits(&captured.request),
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 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_some() {
app.render_workspace.view.completed = Some(job);
} else if 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;
}
}
}
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);
cache_completed_image(app, ctx);
// Checkpoint updates and preview→final/cancel transitions preserve shared pan/zoom.
remember_displayed_job(app, preserve_view);
}
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.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) {
for (view, key) in [("model", "render.state_model"), ("fit", "render.output_fit"), ("actual", "render.result_actual")] {
let enabled = view != "actual" || !reduced_display(app);
if crate::ui_kit::button(ui, app.tr(key), crate::ui_kit::Button::Enabled(enabled)).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 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);
// The floating shell paints after this canvas. Keep image actions in its free
// content area so neither ribbon nor Browser can cover their hit targets.
let mut free = crate::render_ui::canvas(app, ui.max_rect());
if ribbon::busy(app) {
free = crate::ui_kit::Container::below_navigation_row(free);
}
let mut content = ui.new_child(egui::UiBuilder::new().max_rect(free).id_salt("render_result_content"));
let ui = &mut content;
let Some((info, preview)) = displayed_image(app).map(|display| (display.info.clone(), display.preview.cloned())) 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(),
};
crate::ui_kit::Container::navigation_contents(ui, |ui| {
ui.horizontal_wrapped(|ui| {
crate::ui_kit::text(
ui,
app.tr(if ribbon::busy(app) { "render.state_in_progress" } else { "render.result_title" }),
crate::ui_kit::Text::Inline,
);
result_actions(app, ui);
});
});
let canvas = ui.available_rect_before_wrap();
ui.centered_and_justified(|ui| {
ui.add(egui::Label::new(egui::RichText::new(message).size(t.font_heading).color(t.text)).wrap());
});
app.viewport.rect = Some(canvas);
return;
};
crate::ui_kit::Container::navigation_contents(ui, |ui| {
ui.horizontal_wrapped(|ui| {
crate::ui_kit::text(
ui,
app.tr(if preview.is_some() { "render.state_in_progress" } else { "render.state_completed" }),
crate::ui_kit::Text::Inline,
);
result_actions(app, ui);
});
if let Some(preview) = &preview {
ui.colored_label(
t.warning,
format!(
"{} · {} {} · {} {}",
app.tr("render.result_provisional"),
preview.samples_per_pixel,
app.tr("render.cpu_progressive_spp"),
app.tr("render.result_sequence"),
preview.frame_sequence
),
);
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"));
}
});
let rect = ui.available_rect_before_wrap();
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 scale != ResultScale::Free {
app.render_workspace.view.result_camera = result_camera(size, rect, ui.ctx().pixels_per_point(), scale);
}
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 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
{
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);
}
painter.rect_stroke(image_rect, 0.0, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Outside);
}
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);
crate::navigation_bar_view::show(app, ui, rect);
}
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 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)
}
pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
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 = shot::preview_rect(app, viewport).unwrap_or(viewport);
crate::viewport::refresh_layout(app, ui.ctx());
let response = ui.interact(rect, ui.id().with("render_preview"), Sense::click_and_drag());
if !environment::ring_input(app, ui, rect, &response) {
let input = crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps::RENDER);
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(|_| input.inside && !navigating)
.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(), input.inside && !navigating);
if !assigning && input.inside && !navigating {
assign::hover_tooltip(app, &response, candidate.as_ref());
}
if !assigning && response.clicked_by(egui::PointerButton::Primary) && input.inside && !navigating {
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;
}
let bg = app.render_workspace.view.draft.background;
ui.painter().rect_filled(viewport, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2]));
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 (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 mut visibility = std::collections::hash_map::DefaultHasher::new();
app.session.visibility.hidden_bodies.hash(&mut visibility);
app.session.visibility.hidden_occurrences.hash(&mut visibility);
let budget = preferred_geometry_budget(app.render_workspace.geometry_budget, app.preferences.render_previous_geometry_budget);
let signature =
(app.session.revision, Arc::as_ptr(&app.session.world_state()) as usize, visibility.finish() ^ 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 camera = app.cam;
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 callback = ViewportCallback(Frame {
product_lights: 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,
view_proj: camera.view_proj(f64::from(rect.width() / rect.height().max(1.0)), radius).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(),
points: 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,
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]
},
});
ui.painter().add(egui_wgpu::Callback::new_paint_callback(rect, callback));
Ok(())
})();
if let Err(error) = result {
preview_error(app, ui, rect, &error);
}
shot::overlay(app, ui, viewport);
crate::viewport::axis_view(app, ui, viewport);
crate::navigation_bar_view::show(app, ui, viewport);
}
/// 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> {
match id {
"render.preflight.copy" => {
app.render_workspace.clipboard_text = Some(reply["text"].as_str().ok_or("invalid check report")?.to_string());
}
"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";
match view {
"fit" => fit_result(app),
"actual" => app.render_workspace.view.result_scale = ResultScale::Actual,
_ => {}
}
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(())
}
pub(crate) fn progress_pill(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
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 cancel =
crate::ui_kit::progress_action(ui, &format!("{name} · {} · {:.0}%", app.tr(&phase_key), fraction * 100.0), 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);
// 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 start_interactive(app: &mut SolveApp, id: &str) -> bool {
let handled = assign::start(app, id) || ribbon::start(app, id);
// Opening Appearance Advanced must still reach its atmosphere controls after leaving Wear.
if handled
&& id == "render.aging.describe"
&& app.render_workspace.view.inspector.page == inspector::Page::Appearance
&& app.render_workspace.view.selection == RenderSelection::Wear
{
let _ = app.run("view.render_select", json!({"kind":"nothing"}));
// Clearing semantic focus routes to Scene; retain the explicit Advanced destination.
app.render_workspace.view.inspector.page = inspector::Page::Appearance;
}
handled
}