Skip to content

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

29.7 KB
Raw Blame
//! Automatic, isolated product-image feedback. The original session owns final results only.
//! A scratch session reuses the same commands, immutable model and installed host pools.
use std::hash::{Hash, Hasher};
use std::sync::{
    Arc, Weak,
    atomic::{AtomicBool, Ordering},
    mpsc,
};

use egui::{Context, Rect, TextureHandle, emath::GuiRounding as _};
use serde_json::{Value, json};
use solidcraft_engine::{
    Session,
    doc::Document,
    render::job::{CpuProgressiveOptions, JobHandle, JobId, Phase},
};

use super::{ImageMethod, ribbon};
use crate::{SolveApp, ui_kit};

const LONGEST_EDGE: u32 = 512;
const EDIT_DELAY_SECONDS: f64 = 0.2;

#[derive(Clone)]
struct Identity {
    document: Weak<Document>,
    revision: u64,
    model: Weak<solidcraft_engine::doc::ModelState>,
    moves: std::collections::BTreeMap<u64, solidcraft_engine::doc::Mat>,
    visibility: u64,
    shot: String,
    request: Value,
}
impl Identity {
    fn same(&self, other: &Self) -> bool {
        Weak::ptr_eq(&self.document, &other.document)
            && self.revision == other.revision
            && Weak::ptr_eq(&self.model, &other.model)
            && self.moves == other.moves
            && self.visibility == other.visibility
            && self.shot == other.shot
            && self.request == other.request
    }
}

struct OwnedJob {
    // Keep the scratch session alive: dropping its Jobs cancels its live handles.
    _owner: Session,
    handle: JobHandle,
    generation: u64,
    revision: u64,
    target: u32,
}
struct Pending {
    receiver: mpsc::Receiver<Result<OwnedJob, String>>,
    cancelled: Arc<AtomicBool>,
    generation: u64,
}
struct Picture {
    generation: u64,
    job: JobId,
    sequence: u32,
    samples: u32,
    complete: bool,
    adaptive: Option<solidcraft_engine::render::job::adaptive::AdaptivePreview>,
    executor: solidcraft_engine::render::ExecutorId,
    /// Captured alongside this texture from the same validated immutable frame.
    scene_generation: u64,
    size: [u32; 2],
    texture: TextureHandle,
}
#[derive(Default)]
pub(crate) struct State {
    identity: Option<Identity>,
    generation: u64,
    due: f64,
    attempted: bool,
    pending: Option<Pending>,
    running: Option<OwnedJob>,
    picture: Option<Picture>,
    error: Option<String>,
    suspended: bool,
    draining: Vec<JobHandle>,
    final_request: Option<ribbon::PendingFinal>,
}
impl Drop for State {
    fn drop(&mut self) {
        self.cancel_work();
    }
}
impl State {
    pub(super) fn retire_document(&mut self) {
        self.reset();
        self.final_request = None;
        self.suspended = true;
    }
    fn cancel_work(&mut self) {
        if let Some(pending) = &self.pending {
            pending.cancelled.store(true, Ordering::Release);
        }
        if let Some(job) = self.running.take() {
            let _ = job.handle.cancel();
            self.draining.push(job.handle.clone());
        }
    }
    fn reset(&mut self) {
        self.cancel_work();
        self.identity = None;
        self.attempted = false;
        self.picture = None;
        self.error = None;
    }
    fn observe(&mut self, identity: Identity, now: f64) {
        if self.identity.as_ref().is_some_and(|old| old.same(&identity)) {
            return;
        }
        self.cancel_work();
        self.generation = self.generation.saturating_add(1);
        self.identity = Some(identity);
        self.due = now + EDIT_DELAY_SECONDS;
        self.attempted = false;
        self.error = None;
    }
    fn poll_capture(&mut self) {
        let Some(pending) = &self.pending else { return };
        let answer = match pending.receiver.try_recv() {
            Ok(answer) => answer,
            Err(mpsc::TryRecvError::Empty) => return,
            Err(mpsc::TryRecvError::Disconnected) => Err(crate::i18n::tr("render.live.worker_stopped").into()),
        };
        let generation = pending.generation;
        let cancelled = pending.cancelled.load(Ordering::Acquire);
        self.pending = None;
        match answer {
            Ok(job) if generation == self.generation && !cancelled && !self.suspended => self.running = Some(job),
            Ok(job) => {
                let _ = job.handle.cancel();
                self.draining.push(job.handle.clone());
            }
            Err(error) if generation == self.generation && !cancelled && !self.suspended => self.error = Some(error),
            Err(_) => {}
        }
    }
    fn reap_draining(&mut self) {
        self.draining.retain(|handle| !handle.work_released());
    }
    fn poll_pixels(&mut self, ctx: &Context) {
        let Some(job) = &self.running else { return };
        if job.generation != self.generation {
            return;
        }
        let result = (|| -> Result<Option<Picture>, String> {
            let status = job.handle.status().map_err(|e| e.to_string())?;
            if status.job != job.handle.id() || status.scene_generation != job.revision {
                return Err(crate::i18n::tr("render.error_provisional_identity").into());
            }
            if let Some(error) = &status.error {
                return Err(error.to_string());
            }
            let limits = if status.resolved.executor.as_str() == "gpu-path" {
                solidcraft_engine::render::job::GPU_PATH_LIMITS
            } else {
                super::captured_image_limits(&status.request)
            };
            let current = self.picture.as_ref().filter(|picture| picture.generation == job.generation && picture.job == job.handle.id());
            let load = |info: &solidcraft_engine::render::job::FrameInfo, png: &[u8], sequence, samples, complete, adaptive| {
                if info.job != job.handle.id()
                    || info.scene_generation != job.revision
                    || info.executor != status.resolved.executor
                    || (info.width, info.height) != (status.request.width, status.request.height)
                {
                    return Err(crate::i18n::tr("render.error_provisional_identity").to_string());
                }
                let image = super::decode_render_image(png, info.width, info.height, limits, ctx.input(|i| i.max_texture_side))?;
                Ok(Picture {
                    generation: job.generation,
                    job: info.job,
                    sequence,
                    samples,
                    complete,
                    adaptive,
                    executor: info.executor.clone(),
                    scene_generation: info.scene_generation,
                    size: [info.width, info.height],
                    texture: ctx.load_texture("sc_render_live", image, egui::TextureOptions::LINEAR),
                })
            };
            if let Some(frame) = job.handle.frame().map_err(|e| e.to_string())? {
                if current.is_some_and(|picture| picture.complete) {
                    return Ok(None);
                }
                let adaptive = super::captured_adaptive_preview(&status, job.target)?;
                return load(&frame.info, frame.png(), current.map_or(1, |picture| picture.sequence), job.target, true, adaptive).map(Some);
            }
            if let Some(preview) = job.handle.preview().map_err(|e| e.to_string())? {
                if current.is_some_and(|picture| picture.sequence >= preview.info.frame_sequence) {
                    return Ok(None);
                }
                let adaptive = super::captured_adaptive_preview(&status, preview.info.samples_per_pixel)?;
                if preview.info.frame_sequence == 0
                    || preview.info.samples_per_pixel == 0
                    || preview.info.samples_per_pixel >= job.target
                    || preview.info.adaptive != adaptive
                {
                    return Err(crate::i18n::tr("render.error_provisional_identity").into());
                }
                return load(&preview.info.frame, preview.png(), preview.info.frame_sequence, preview.info.samples_per_pixel, false, adaptive)
                    .map(Some);
            }
            if let Some(reason) = status.preview_unavailable_reason {
                return Err(reason.into());
            }
            if matches!(status.progress.phase, Phase::Cancelled | Phase::Failed) {
                return Err(crate::i18n::tr("render.live.stopped").into());
            }
            Ok(None)
        })();
        match result {
            Ok(Some(picture)) => {
                self.picture = Some(picture);
                ctx.request_repaint();
            }
            Ok(None) => {}
            Err(error) => {
                self.error = Some(error);
                self.cancel_work();
            }
        }
    }
}

fn enabled(app: &SolveApp) -> bool {
    !cfg!(target_arch = "wasm32") && !app.preferences.render_legacy_image_defaults && app.render_workspace.view.method != ImageMethod::Raster
}
fn rounded_size(rect: Rect) -> [u32; 2] {
    let width = f64::from(rect.width().max(1.0));
    let height = f64::from(rect.height().max(1.0));
    let longest = width.max(height);
    let scale = (f64::from(LONGEST_EDGE) / longest).min(1.0);
    [(width * scale).round().clamp(1.0, f64::from(LONGEST_EDGE)) as u32, (height * scale).round().clamp(1.0, f64::from(LONGEST_EDGE)) as u32]
}
fn size(app: &SolveApp, rect: Rect) -> [u32; 2] {
    let [width, height] = [app.render_workspace.view.draft.width, app.render_workspace.view.draft.height];
    if width == 0 || height == 0 {
        // Request validates original intent before any temporary live-size copy.
        return rounded_size(rect);
    }
    let (mut a, mut b) = (width, height);
    while b != 0 {
        (a, b) = (b, a % b);
    }
    let unit = [width / a, height / a];
    let maximum_scale = LONGEST_EDGE / unit[0].max(unit[1]);
    if maximum_scale > 0 {
        // Exact common ratios (e.g. 160:120→4:3) stay identical through every
        // free-canvas shape. Never round width/height independently when an
        // admitted integer multiple can preserve the output camera exactly.
        let scale = (f64::from(rect.width()) / f64::from(unit[0]))
            .min(f64::from(rect.height()) / f64::from(unit[1]))
            .floor()
            .clamp(1.0, f64::from(maximum_scale)) as u32;
        return [unit[0] * scale, unit[1] * scale];
    }
    // Coprime authored dimensions can exceed the 512-pixel live ceiling even
    // though the final job is valid. Use the nearest bounded pixel dimensions;
    // projection_rect applies that captured aspect too, without stretching.
    rounded_size(super::shot::frame_rect(f64::from(width) / f64::from(height), rect).unwrap_or(rect))
}

/// Match product navigation, picking and pixels to the exact integer live-capture aspect.
/// At most a pixel of letterboxing is introduced instead of stretching the rendered image.
pub(crate) fn projection_rect(app: &SolveApp, rect: Rect) -> Rect {
    if !enabled(app) || !rect.is_finite() || !rect.is_positive() {
        return rect;
    }
    let [width, height] = size(app, rect);
    super::shot::frame_rect(f64::from(width) / f64::from(height), rect).unwrap_or(rect)
}

/// Build a separate, labelled live-size request. Final size, AA and saved intent are restored
/// before returning, including on refusal. Effects are never removed to obtain a preview.
fn request(app: &mut SolveApp) -> Result<Value, String> {
    super::image_host(app, app.render_workspace.view.method)?;
    if app.session.model.is_stale() {
        return Err(app.tr("render.image_scene_stale").into());
    }
    let old_size = [app.render_workspace.view.draft.width, app.render_workspace.view.draft.height];
    if old_size.contains(&0) {
        return Err(app.tr("render.live.invalid_size").into());
    }
    // A labelled low-resolution live copy must not make invalid authored output
    // dimensions/sampling appear valid. Refuse original intent before scaling.
    let original = (u64::from(old_size[0]), u64::from(old_size[1]));
    if super::cpu::image_limits(app).fit(original.0, original.1, None) != Some(original) {
        return Err(super::inspector::size_limit_reason(app, old_size[0], old_size[1]));
    }
    super::cpu::validate_progressive_image(app)?;
    let old_sampling = app.render_workspace.view.raytrace.progressive;
    let old_primary = app.render_workspace.view.raytrace.primary_samples;
    let old_reflection_samples = app.render_workspace.view.raytrace.reflections.as_ref().map(|options| options.samples);
    let viewport =
        app.viewport.rect.filter(|rect| rect.is_finite() && rect.is_positive()).ok_or_else(|| app.tr("render.live.waiting_canvas").to_string())?;
    let canvas = super::shot::render_rect(app, viewport);
    let live_size = size(app, canvas);
    app.render_workspace.view.draft.width = live_size[0];
    app.render_workspace.view.draft.height = live_size[1];
    if app.render_workspace.view.method == ImageMethod::CpuRaytrace && old_sampling.is_none() {
        app.render_workspace.view.raytrace.progressive = Some(CpuProgressiveOptions::default());
        app.render_workspace.view.raytrace.primary_samples = 1;
        if let Some(reflections) = &mut app.render_workspace.view.raytrace.reflections {
            // A live film ordinal supplies a fresh reflected camera sample. Preserve the
            // authored fixed image's attempt count when this temporary copy is restored.
            reflections.samples = 1;
        }
    }
    let result = super::image_request(app);
    app.render_workspace.view.draft.width = old_size[0];
    app.render_workspace.view.draft.height = old_size[1];
    app.render_workspace.view.raytrace.progressive = old_sampling;
    app.render_workspace.view.raytrace.primary_samples = old_primary;
    if let (Some(reflections), Some(samples)) = (&mut app.render_workspace.view.raytrace.reflections, old_reflection_samples) {
        reflections.samples = samples;
    }
    result
}
fn target(request: &Value) -> u32 {
    let samples = request
        .pointer("/settings/job/options/progressive/samples_per_pixel")
        .or_else(|| request.pointer("/raytrace/progressive/samples_per_pixel"))
        .or_else(|| request.pointer("/settings/job/options/samples"))
        .or_else(|| request.get("samples"))
        .and_then(Value::as_u64)
        .and_then(|n| u32::try_from(n).ok())
        .unwrap_or(1);
    let pilots = request
        .pointer("/settings/job/options/adaptive/pilot_samples")
        .or_else(|| request.pointer("/raytrace/adaptive/pilot_samples"))
        .or_else(|| request.pointer("/adaptive/pilot_samples"))
        .and_then(Value::as_u64)
        .and_then(|n| u32::try_from(n).ok())
        .unwrap_or(0);
    samples.checked_add(pilots).unwrap_or(0)
}

#[cfg(not(target_arch = "wasm32"))]
fn capture(app: &SolveApp, identity: &Identity, generation: u64) -> Result<Pending, String> {
    let mut owner = app.session.scratch();
    let request = identity.request.clone();
    let revision = identity.revision;
    let target = target(&request);
    let scope = solidcraft_engine::io::vfs::current_scope();
    let cancelled = Arc::new(AtomicBool::new(false));
    let stop = cancelled.clone();
    let (sender, receiver) = mpsc::channel();
    solidcraft_engine::kernel::kernel_thread("render-live-capture")
        .spawn(move || {
            let result = solidcraft_engine::io::vfs::scoped(scope, || {
                if stop.load(Ordering::Acquire) {
                    return Err(crate::i18n::tr("render.live.stopped").to_string());
                }
                let reply = owner.execute("render.start", &request).map_err(|e| e.to_string())?;
                let id = serde_json::from_value(reply["job"].clone()).map_err(|e| format!("{e}"))?;
                let handle = owner.render_job_handle(id).map_err(|e| e.to_string())?;
                if stop.load(Ordering::Acquire) {
                    let _ = handle.cancel();
                }
                // The UI must keep this handle until work_released, even if cancellation
                // raced submission. A terminal/cancelled status alone does not release work.
                Ok(OwnedJob { _owner: owner, handle, generation, revision, target })
            });
            let _ = sender.send(result);
        })
        .map_err(|e| e.to_string())?;
    Ok(Pending { receiver, cancelled, generation })
}

pub(crate) fn tick(app: &mut SolveApp, ctx: &Context) {
    let now = ctx.input(|input| input.time);
    tick_at(app, ctx, now);
}
fn tick_at(app: &mut SolveApp, ctx: &Context, now: f64) {
    let mut state = std::mem::take(&mut app.render_workspace.live);
    state.poll_capture();
    state.reap_draining();
    if state.final_request.is_some() {
        state.cancel_work();
        state.suspended = true;
        if state.pending.is_none() && state.draining.is_empty() {
            let pending = state.final_request.take();
            app.render_workspace.live = state;
            if let Some(pending) = pending
                && let Err(error) = ribbon::submit_deferred(app, pending)
            {
                app.set_status(error, true);
            }
        } else {
            ctx.request_repaint_after(std::time::Duration::from_millis(20));
            app.render_workspace.live = state;
        }
        return;
    }
    if !enabled(app) || !super::active(app) {
        state.reset();
        state.suspended = true;
        state.poll_capture();
        if state.pending.is_some() || !state.draining.is_empty() {
            ctx.request_repaint_after(std::time::Duration::from_millis(20));
        }
        app.render_workspace.live = state;
        return;
    }
    let request = request(app);
    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 identity = Identity {
        document: Arc::downgrade(&app.session.doc),
        revision: app.session.revision,
        model: Arc::downgrade(&app.session.model.state()),
        moves: app.session.pending_moves.clone(),
        visibility: visibility.finish(),
        shot: app.render_workspace.view.name.clone(),
        request: request.as_ref().cloned().unwrap_or_else(|error| json!({"error":error})),
    };
    state.observe(identity, now);
    let suspended = app.render_workspace.view.live_paused
        || ribbon::busy(app)
        || app.render_workspace.view.result
        || app.render_workspace.view.compare.is_some()
        || app.file_load.busy()
        || app.file_picker.is_some()
        || app.saving.is_some()
        || app.tool.is_some()
        || app.dialog.is_some();
    if suspended {
        state.cancel_work();
        state.attempted = false;
        state.suspended = true;
        state.poll_capture();
        if state.pending.is_some() || !state.draining.is_empty() {
            ctx.request_repaint_after(std::time::Duration::from_millis(20));
        }
        app.render_workspace.live = state;
        return;
    }
    state.suspended = false;
    state.poll_capture();
    if let Err(error) = request {
        state.error = Some(error);
        state.attempted = true;
    }
    state.poll_pixels(ctx);
    if state.pending.is_none() && state.running.is_none() && state.draining.is_empty() && !state.attempted && now >= state.due {
        state.attempted = true;
        #[cfg(not(target_arch = "wasm32"))]
        if let Some(identity) = &state.identity {
            match capture(app, identity, state.generation) {
                Ok(pending) => state.pending = Some(pending),
                Err(error) => state.error = Some(error),
            }
        }
    }
    if state.pending.is_some()
        || !state.draining.is_empty()
        || (state.running.is_some() && !state.picture.as_ref().is_some_and(|picture| picture.complete && picture.generation == state.generation))
        || !state.attempted
    {
        ctx.request_repaint_after(std::time::Duration::from_millis(20));
    }
    app.render_workspace.live = state;
}

pub(crate) fn set_paused(app: &mut SolveApp, paused: bool) {
    app.render_workspace.view.live_paused = paused;
    if paused {
        app.render_workspace.live.cancel_work();
    } else {
        app.render_workspace.live.identity = None;
        app.render_workspace.live.attempted = false;
    }
}
/// Preparation owns the same live-release priority as an explicit final. The
/// original pending/running owners stay here until their release acknowledgements.
pub(super) fn suspend_for_preparation(app: &mut SolveApp) {
    let state = &mut app.render_workspace.live;
    state.cancel_work();
    state.suspended = true;
    state.identity = None;
    state.attempted = false;
    state.poll_capture();
    state.reap_draining();
}
pub(super) fn preparation_ready(app: &SolveApp) -> bool {
    let state = &app.render_workspace.live;
    state.pending.is_none() && state.running.is_none() && state.draining.is_empty()
}
pub(super) fn defer_final(app: &mut SolveApp, request: ribbon::PendingFinal) -> bool {
    let state = &mut app.render_workspace.live;
    state.cancel_work();
    state.suspended = true;
    state.identity = None;
    state.attempted = false;
    state.reap_draining();
    if state.pending.is_some() || !state.draining.is_empty() {
        state.final_request = Some(request);
        true
    } else {
        false
    }
}
pub(super) fn final_pending(app: &SolveApp) -> bool {
    app.render_workspace.live.final_request.is_some()
}
pub(super) fn cancel_final(app: &mut SolveApp) -> bool {
    app.render_workspace.live.final_request.take().is_some()
}
fn picture_current(app: &SolveApp) -> bool {
    let state = &app.render_workspace.live;
    let Some(identity) = &state.identity else { return false };
    let Some(viewport) = app.viewport.rect.filter(|rect| rect.is_finite() && rect.is_positive()) else { return false };
    let [width, height] = size(app, super::shot::render_rect(app, viewport));
    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);
    // Navigation runs after the frame's lifecycle tick. Check geometry/camera again before
    // picking or painting feedback, so this frame cannot overlay a new camera on old pixels.
    enabled(app)
        && state.picture.as_ref().is_some_and(|picture| picture.generation == state.generation)
        && state.error.is_none()
        && Weak::ptr_eq(&identity.document, &Arc::downgrade(&app.session.doc))
        && identity.revision == app.session.revision
        && Weak::ptr_eq(&identity.model, &Arc::downgrade(&app.session.model.state()))
        && identity.moves == app.session.pending_moves
        && identity.visibility == visibility.finish()
        && identity.request.pointer("/settings/camera") == Some(&json!(app.cam))
        && identity.request.pointer("/settings/width").and_then(Value::as_u64) == Some(u64::from(width))
        && identity.request.pointer("/settings/height").and_then(Value::as_u64) == Some(u64::from(height))
}
pub(crate) fn picking_current(app: &SolveApp) -> bool {
    let state = &app.render_workspace.live;
    !enabled(app) || state.picture.is_none() || picture_current(app)
}
/// Terminal status precedes native cleanup. Live admission waits for that final work too.
pub(super) fn drain_final(app: &mut SolveApp, handle: JobHandle) {
    if !handle.work_released() {
        app.render_workspace.live.draining.push(handle);
    }
}
pub(crate) fn paint(app: &mut SolveApp, ui: &egui::Ui, rect: Rect) {
    if !enabled(app) {
        return;
    }
    if let Some(picture) = &app.render_workspace.live.picture {
        let aspect = f64::from(picture.size[0]) / f64::from(picture.size[1].max(1));
        if let Some(image) = super::shot::frame_rect(aspect, rect) {
            let source = super::displayed::Source {
                job: picture.job,
                scene_generation: picture.scene_generation,
                width: picture.size[0],
                height: picture.size[1],
                kind: if picture.complete { super::displayed::Kind::LiveFinal } else { super::displayed::Kind::LivePreview },
                frame_sequence: Some(picture.sequence),
                samples_per_pixel: Some(picture.samples),
                adaptive: picture.adaptive,
            };
            egui::Image::new(&picture.texture).paint_at(ui, image);
            // Image::paint_at rounds to physical pixels before emitting its image shape.
            app.render_workspace.displayed.record(ui.painter(), image.round_to_pixels(ui.pixels_per_point()), source);
        }
    }
}
pub(crate) fn has_picture(app: &SolveApp) -> bool {
    enabled(app) && app.render_workspace.live.picture.is_some()
}
/// Describe the image that is actually painted, including a retained previous capture.
/// The selected draft method cannot rename pixels produced by another executor.
pub(crate) fn source_note(app: &SolveApp) -> (String, &'static str) {
    let Some(picture) = app.render_workspace.live.picture.as_ref().filter(|_| has_picture(app)) else {
        return (app.tr("render.stage_preview_note").into(), "render.preview_lighting_help");
    };
    let method_matches = matches!(
        (picture.executor.as_str(), app.render_workspace.view.method),
        ("cpu-raytrace", ImageMethod::CpuRaytrace) | ("gpu-path", ImageMethod::GpuRaytrace)
    );
    let current = method_matches && picture_current(app);
    (source_text(app, picture.executor.as_str(), current), if current { "render.live.quality_help" } else { "render.live.source_outdated_help" })
}

pub(super) fn source_text(app: &SolveApp, executor: &str, current: bool) -> String {
    let method = match executor {
        "cpu-raytrace" => app.tr("render.method_cpu"),
        "gpu-path" => app.tr("render.method_gpu"),
        _ => executor,
    };
    crate::i18n::format(if current { "render.live.source_current" } else { "render.live.source_outdated" }, &[("method", method)])
}

pub(crate) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    if !enabled(app) {
        return;
    }
    let state = &app.render_workspace.live;
    let status = if app.render_workspace.view.live_paused {
        app.tr(if state.picture.as_ref().is_some_and(|picture| picture.generation != state.generation) {
            "render.live.paused_outdated"
        } else {
            "render.live.paused"
        })
        .to_string()
    } else if let Some(error) = &state.error {
        crate::i18n::format("render.live.refused", &[("reason", error)])
    } else if let Some(picture) = &state.picture {
        if picture.generation == state.generation && !state.suspended {
            if let Some(adaptive) = picture.adaptive {
                crate::i18n::format(
                    "render.live.adaptive",
                    &[
                        ("width", &picture.size[0].to_string()),
                        ("height", &picture.size[1].to_string()),
                        ("progress", &super::adaptive_preview_label(app, adaptive)),
                    ],
                )
            } else {
                let target = state.running.as_ref().map_or(picture.samples, |job| job.target);
                crate::i18n::format(
                    "render.live.samples",
                    &[
                        ("current", &picture.samples.to_string()),
                        ("target", &target.to_string()),
                        ("width", &picture.size[0].to_string()),
                        ("height", &picture.size[1].to_string()),
                    ],
                )
            }
        } else {
            app.tr("render.live.updating").into()
        }
    } else {
        app.tr("render.live.updating").into()
    };
    let paused = app.render_workspace.view.live_paused;
    let label = app.tr(if paused { "render.live.resume" } else { "render.live.pause" }).to_string();
    let response = ui_kit::button(ui, &label, ui_kit::Button::Normal);
    crate::scenario::publish_target("render:live:pause", response.rect);
    if response.clicked() {
        let _ = app.run("view.render_live", json!({"paused":!paused}));
    }
    let max_width = ui.available_width().min(crate::theme::Tokens::get().control_height * 10.0);
    let mut help = format!("{status}\n\n{}", app.tr("render.live.quality_help"));
    if app.render_workspace.live.picture.as_ref().is_some_and(|picture| picture.adaptive.is_some()) {
        help.push_str("\n\n");
        help.push_str(app.tr("render.adaptive.preview_help"));
    }
    let note = ui_kit::StageBar::note_bounded(ui, &status, max_width).on_hover_text(help);
    crate::scenario::publish_target("render:live:status", note.rect);
    ui_kit::StageBar::separator(ui);
}

pub(super) fn inspect(app: &SolveApp) -> Value {
    let state = &app.render_workspace.live;
    let is_current = picture_current(app);
    json!({"enabled":enabled(app),"paused":app.render_workspace.view.live_paused,"generation":state.generation,"draining":state.draining.len(),"final_pending":state.final_request.is_some(),"suspended":state.suspended,"pending":state.pending.is_some(),"running":state.running.is_some(),"error":state.error,
        "target":state.running.as_ref().map(|job|job.target).or_else(||state.identity.as_ref().map(|identity|target(&identity.request))),
        "current":state.picture.as_ref().map(|picture|picture.samples),"is_current":is_current,"stale":state.picture.is_some() && !is_current,
        "job":state.running.as_ref().map(|job|job.handle.id()).or_else(||state.picture.as_ref().map(|picture|picture.job)),"samples":state.picture.as_ref().map(|picture|picture.samples),
        "sequence":state.picture.as_ref().map(|picture|picture.sequence),"request":state.identity.as_ref().map(|identity| &identity.request),
        "adaptive":state.picture.as_ref().and_then(|picture|picture.adaptive),
        "hash":state.running.as_ref().and_then(|job| job.handle.frame().ok().flatten()).map(|frame| frame.info.png_sha256.clone()),"complete":is_current && state.picture.as_ref().is_some_and(|picture|picture.complete)})
}
#[cfg(test)]
pub(super) fn advance(app: &mut SolveApp, ctx: &Context, now: f64) {
    tick_at(app, ctx, now);
}