//! 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; use solidcraft_engine::render::job::{ImageHost, Integrator, LightingPreset, 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_inspector.rs"] mod inspector; #[path = "render_workspace_library.rs"] mod library; #[path = "render_workspace_materials.rs"] mod materials; #[path = "render_workspace_setups.rs"] mod setups; #[path = "render_workspace_studio.rs"] mod studio; #[path = "render_workspace_transport.rs"] mod transport; #[cfg(test)] #[path = "render_workspace_tests.rs"] mod tests; type PathFactory = Box Result + Send>; pub struct State { pending_setup: Option, pub host: Option, 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, /// The viewport adapter the current setup runs on. pub setup_key: Option, pub image_host: Option, pub view: ViewState, revision: u64, design_camera: Option<(Camera, bool)>, slot: SceneSlot, key: Option, scene_signature: Option<(u64, usize, u64)>, scene: Option, scene_error: Option, preview_upload_bytes: Option, image: Option<(solidcraft_engine::render::job::JobId, Result)>, image_info: Option, preview_image: Option, } /// Provisional pixels are never an export source and never replace the retained final image. struct PreviewImage { info: PreviewInfo, image: Result, } struct DisplayImage<'a> { info: &'a solidcraft_engine::render::job::FrameInfo, image: &'a Result, 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>, std::time::Instant), Ready(ImageHost), Failed(String), } impl PathHost { #[cfg(not(target_arch = "wasm32"))] pub(crate) fn start(&mut self, create: impl FnOnce() -> Result + 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("GPU path tracer setup panicked".into())); let _ = tx.send(result); }) { Ok(_) => Self::Preparing(rx, std::time::Instant::now()), Err(e) => Self::failed(format!("could not start setup worker: {e}")), }; } 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 { 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("setup worker stopped without returning a host".into()), }; matches!(self, Self::Ready(_)).then_some(took) } } /// The samples slider's top end: 2^12 = 4096 samples per pixel. 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 { 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")); } } } } /// Small per-document editor state; GPU uploads and host capabilities stay outside tabs. #[derive(Clone, Debug)] pub struct ViewState { pub name: String, draft: RenderSetup, dirty: bool, clean_setup: Option, job: Option, completed: Option, 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, cpu: cpu::View, overwrite: bool, result: bool, result_camera: Camera, result_scale: ResultScale, result_job: Option, } #[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 { name: "Studio".into(), 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(), 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 { host: None, path_host: PathHost::default(), pending_setup: None, setup_seconds: Default::default(), setup_key: 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, } } } 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 + 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 { app.ui.tab == "RENDER" } 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), "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 { if !matches!(samples, 1 | 2 | 4 | 8 | 16) { return Err("unsupported GPU sample count".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: "product preview requires an installed device with a depth buffer".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 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), } } } pub fn reset_document(app: &mut SolveApp) { app.ui.ribbon_context = None; let host = app.render_workspace.host.clone(); let image_host = app.render_workspace.image_host.clone(); 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, ..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.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("finish the current modelling operation before entering Render".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(); let scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|e| e.to_string())?; if !scene.bounds.is_empty() { app.cam.fit(&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 { 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(); } app.cancel_view_animation(); Ok(()) } pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { inspector::panel(app, ui); } /// 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; } let labels = [app.tr("render.browser_model").to_string(), app.tr("render.browser_library").to_string()]; let mut selected = usize::from(app.render_workspace.view.inspector.library_open); let top = ui.cursor().min; let width = ui.available_width(); crate::ui_kit::segmented(ui, &mut selected, &labels.iter().map(String::as_str).collect::>(), Default::default()); for (i, name) in ["render:browser-model", "render:browser-library"].iter().enumerate() { crate::scenario::publish_target( name, egui::Rect::from_min_size(top + egui::vec2(width * i as f32 / 2.0, 0.0), egui::vec2(width / 2.0, crate::ui_kit::row_height())), ); } app.render_workspace.view.inspector.library_open = selected == 1; if selected == 1 { crate::ui_kit::scope(ui, |ui| library::browse(app, ui)); true } else { false } } 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 { 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 { 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; } fn method_selector(app: &mut SolveApp, ui: &mut egui::Ui) { ui.label(app.tr("render.image_method")); 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()); if image_host(app, app.render_workspace.view.method).is_err() { if app.render_workspace.view.inspector.page == inspector::Page::All { ui.small(app.tr("render.setup_offline_help")); } else { 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 { if app.render_workspace.view.inspector.page == inspector::Page::All { ui.small(app.tr("render.preview_image_settings_help")); } else { crate::ui_kit::text(ui, app.tr("render.preview_image_settings_help"), crate::ui_kit::Text::Note("render.preview_image_settings_help")); } } } fn cpu_sampling_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let progressive = cpu::progressive_controls(app, ui); if !progressive { ui.label(app.tr("render.cpu_primary_samples")); 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")); } } 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); } 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); } 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() }) { app.render_workspace.view.result = selected == 1; app.cancel_view_animation(); app.viewport.key_hold = None; app.viewport.orbit_free = None; } 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() { fit_result(app); } if crate::ui_kit::button(ui, "100%", crate::ui_kit::Button::Enabled(!reduced_display(app))) .on_hover_text(app.tr("render.result_actual_help")) .clicked() { app.render_workspace.view.result_scale = ResultScale::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); }); } 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) = ¶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("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) = ¶ms { 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. 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() { app.render_workspace.view.result = true; app.cancel_view_animation(); app.viewport.key_hold = None; app.viewport.orbit_free = None; } } 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 { 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("render has 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> { 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 { if info.frame_sequence == 0 || !(1..=4096).contains(&info.samples_per_pixel) { return Err("invalid provisional render identity or sample count".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("checkpoint dimensions differ from the captured request".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("invalid image 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("image display cannot fit this device")?; Ok((u32::try_from(w).map_err(|_| "display width overflow")?, u32::try_from(h).map_err(|_| "display height overflow")?)) } #[cfg(test)] fn decode_image(png: &[u8], width: u32, height: u32) -> Result { 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 { let size = (u64::from(width), u64::from(height)); if budget.fit(size.0, size.1, None) != Some(size) { return Err("render image exceeds its captured resource 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("image decode budget overflow")?); reader.limits(limits); let image = reader.decode().map_err(|e| e.to_string())?.to_rgba8(); if image.dimensions() != (width, height) { return Err("render image dimensions do not match its job".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 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 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(), _ => app.tr("render.result_empty").to_string(), }; 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 = None; return; }; egui::Frame::NONE.fill(t.panel).inner_margin(t.space_8).show(ui, |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().pixels_per_point()); 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)), Color32::WHITE); } 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); } impl State { fn prepare_preview(&mut self, signature: (u64, usize, u64), capture: impl FnOnce() -> Result) -> Result<(), String> { if self.scene_signature != Some(signature) { let prepared = capture().and_then(|scene| gpu_scene(&scene).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 = "product preview upload slot unavailable".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); } 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 = rect.shrink(t.space_12); ui.scope_builder(egui::UiBuilder::new().max_rect(bounded), |ui| { 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("The render export document changed while choosing its destination", 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("The render export document changed while choosing its destination", 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 { self.pbr.checked_add(self.tris).and_then(|n| n.checked_add(self.glass)).ok_or_else(|| "product geometry size overflow".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("product geometry size overflow")?; let count = if pbr { &mut self.pbr } else if glass { &mut self.glass } else { &mut self.tris }; *count = count.checked_add(bytes).ok_or("product geometry size overflow")?; if self.bytes()? > limit { return Err(format!("product preview exceeds its {} MiB vertex payload envelope; geometry was not simplified", limit / (1024 * 1024))); } Ok(()) } } fn preview_upload_plan(scene: &ProductScene, limit: usize) -> Result { if scene.meshes.len() > solidcraft_engine::render::job::MAX_CPU_BODIES { return Err("product preview exceeds its captured-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("product triangle count overflow")?; if plan.source_triangles > solidcraft_engine::render::job::MAX_CPU_TRIANGLES { return Err("product preview exceeds its eight-million-triangle source bound".into()); } if body.faces.len() > 262_144 { return Err("product preview exceeds the face-appearance admission 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("invalid product appearance opacity".into()); } let looks: std::collections::BTreeMap<_, _> = body.faces.iter().map(|face| (face.face, face)).collect(); if looks.len() != body.faces.len() { return Err("duplicate product face appearance".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("opaque PBR requires opacity 1".into()); } if opacity > 0.0 { plan.add(pbr, opacity < 0.999, 1, limit)?; } } } 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. pub fn gpu_scene(scene: &ProductScene) -> Result<(u64, GpuScene), String> { let plan = preview_upload_plan(scene, MAX_GEOMETRY_BYTES)?; 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(|_| "product preview vertex allocation failed".to_string())?; } for body in &scene.meshes { if body.faces.len() > 262_144 { return Err("product preview exceeds the face-appearance admission 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("invalid product appearance 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("opaque PBR requires opacity 1".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("invalid 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("PBR requires nonzero 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("product preview packing differs from its admitted vertex payload".into()); } Ok((hash.finish(), gpu)) } fn hash_surface(surface: Option, 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 { show_result(app, ui); return; } let rect = ui.max_rect(); app.viewport.rect = Some(rect); crate::viewport::refresh_layout(app, ui.ctx().pixels_per_point()); let response = ui.interact(rect, ui.id().with("render_preview"), Sense::click_and_drag()); // The modelling viewport's camera input (preset, Orbit around, zoom to the cursor, middle // double-click), with nothing to pick or select here. crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps::RENDER); let bg = app.render_workspace.view.draft.background; ui.painter().rect_filled(rect, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2])); let result = (|| -> Result<(), String> { if app.viewport.gpu.is_none() { return Err("GPU product preview is unavailable on this host. Saved setups remain available.".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("fixed studio preview requires exposure 0, environment rotation 0 and intensity 1".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("finish the modelling gesture before previewing".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 signature = (app.session.revision, Arc::as_ptr(&crate::open_meshing::session_world(&app.session)) as usize, visibility.finish()); app.render_workspace .prepare_preview(signature, || solidcraft_engine::product_scene::extract(&app.session).map_err(|error| error.to_string()))?; let scene = app.render_workspace.scene.as_ref().ok_or("no product scene")?; 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("no product geometry")?; if scene.bounds.is_empty() { return Err("Create a visible solid in Design to preview it here.".into()); } let camera = app.cam; let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(camera.target); let eye = camera.eye(); let slot = app.render_workspace.slot.clone(); let callback = ViewportCallback(Frame { product: true, key, slot: slot.clone(), sketch_key: 0, sketch_slot: slot.clone(), hl_key: 0, hl_slot: 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(), 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, 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: [0.0; 3], selection_tint: [0.0; 3], }); ui.painter().add(egui_wgpu::Callback::new_paint_callback(rect, callback)); Ok(()) })(); if let Err(error) = result { preview_error(app, ui, rect, &error); } crate::viewport::axis_view(app, ui, rect); } pub(crate) fn interactive_command_info(app: &SolveApp, command: &solidcraft_engine::CommandSpec) -> solidcraft_engine::CommandInfo { ribbon::command_info(app, command) } pub(crate) fn start_interactive(app: &mut SolveApp, id: &str) -> bool { ribbon::start(app, id) }