Skip to content

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

32.9 KB
Raw Blame
//! Saved-job adapters. HDR payloads are captured by the engine; paths and body identities stay local.
use solidcraft_engine::doc::render_resources::{CpuHdrEnvironment, GpuHdrEnvironment};
use solidcraft_engine::doc::render_settings::{CpuJob, GpuJob, RenderJob, RenderSetup, SkyEnvironment};
use solidcraft_engine::render::job::{AreaLights, RaytraceEnvironmentOptions, RaytraceOptions, StudioLighting};

use super::{ImageMethod, cpu, hdr, materials, studio};
use crate::SolveApp;

/// Unsaved inputs protect local shot edits and independent navigation. Portable
/// Glass and coat drafts remain unsaved while using the typed capture route.
pub(super) fn has_runtime_inputs(app: &SolveApp) -> bool {
    requires_runtime_request(app)
        || app.render_workspace.view.materials.bindings.iter().any(|binding| binding.has_unsaved_coat_intent() || binding.has_unsaved_optics_intent())
}

/// File sources and ordinal Glass/maps use the runtime request schema. Stable
/// Glass and coat drafts overlay targets into typed captured settings instead.
pub(super) fn requires_runtime_request(app: &SolveApp) -> bool {
    has_runtime_bindings(app) || hdr::active(app).is_some_and(|target| !hdr::input(app, target).embedded())
}

pub(super) fn has_unportable_bindings(app: &SolveApp) -> bool {
    !app.render_workspace.view.materials.bindings.is_empty() || has_runtime_bindings(app)
}

fn has_runtime_bindings(app: &SolveApp) -> bool {
    let view = &app.render_workspace.view;
    if view.materials.bindings.iter().any(super::materials::Binding::has_runtime_intent) {
        return true;
    }
    match view.method {
        ImageMethod::Raster | ImageMethod::GpuRaytrace => false,
        ImageMethod::CpuRaytrace => {
            let options = &view.raytrace;
            options.reflections.is_some()
                || options.anisotropic_faces.iter().any(Option::is_some)
                || !options.dielectrics.is_empty()
                || options.surface_effects.is_some()
                || options.emissions.is_some()
                || options.aging.is_some()
                || options.sky.is_some()
                || (options.sun.is_some() && !view.studio.sun_enabled)
                || (options.volume.is_some() && view.studio.volume.is_none())
        }
    }
}

/// Pure construction: saving intent must work with no CPU/GPU host and stale geometry.
pub(super) fn snapshot(app: &SolveApp) -> Result<RenderSetup, String> {
    snapshot_with_lens_override(app, None)
}

/// Validate a prospective lens edit without changing the live draft first. In particular,
/// removing an authored lens remains possible after navigating to orthographic.
pub(super) fn snapshot_with_lens(app: &SolveApp, lens: Option<solidcraft_engine::render::job::ThinLens>) -> Result<RenderSetup, String> {
    snapshot_with_lens_override(app, Some(lens))
}

fn snapshot_with_lens_override(app: &SolveApp, lens: Option<Option<solidcraft_engine::render::job::ThinLens>>) -> Result<RenderSetup, String> {
    cpu::validate_progressive_image(app)?;
    if has_unportable_bindings(app) {
        return Err(app.tr("render.setup_runtime_unsupported").to_string());
    }
    let mut setup = draft(app)?;
    if let Some(lens) = lens {
        match &mut setup.job {
            Some(RenderJob::CpuRaytrace { options, .. }) => options.lens = lens,
            Some(RenderJob::GpuPath { options, .. }) => options.lens = lens,
            _ => return Err(app.tr("render.shot_lens_raytrace_reason").into()),
        }
    }
    validate_snapshot(app, setup)
}

/// Stable saved optical edits stay transient while every ordinary image capture sees
/// the prospective values. Generic Save still requires the explicit optical review.
pub(super) fn image_snapshot(app: &SolveApp) -> Result<RenderSetup, String> {
    cpu::validate_progressive_image(app)?;
    if has_runtime_bindings(app) {
        return Err(app.tr("render.setup_runtime_unsupported").into());
    }
    let mut setup = draft(app)?;
    materials::overlay_saved(app, &mut setup)?;
    validate_snapshot(app, setup)
}

fn validate_snapshot(app: &SolveApp, setup: RenderSetup) -> Result<RenderSetup, String> {
    // Preserve unsupported legacy intent visibly instead of erasing it while upgrading a setup.
    if setup.environment_rotation != 0.0 || setup.environment_intensity != 1.0 {
        return Err(app.tr("render.setup_legacy_environment").to_string());
    }
    setup.validate().map_err(|error| error.to_string())?;
    if hdr::active(app).is_some_and(|target| hdr::input(app, target).embedded()) {
        app.session.doc.render.validate_resources(&setup).map_err(|error| error.to_string())?;
    }
    Ok(setup)
}

// Compare editable numerical intent before validation, so an incompatible legacy value
// or a lens temporarily paired with an orthographic camera cannot disable dirty tracking.
pub(super) fn draft(app: &SolveApp) -> Result<RenderSetup, String> {
    let view = &app.render_workspace.view;
    let mut setup = RenderSetup { camera: app.cam, ..view.draft.clone() };
    setup.job = Some(match view.method {
        ImageMethod::Raster => RenderJob::Raster { transparent_background: view.transparent },
        ImageMethod::CpuRaytrace => {
            let options = &view.raytrace;
            RenderJob::CpuRaytrace {
                transparent_background: view.transparent,
                options: Box::new(CpuJob {
                    caustics: view.studio.caustics,
                    volume: view.studio.volume,
                    sun: view.studio.sun_enabled.then_some(view.studio.sun),
                    sky: (view.cpu.environment == cpu::Environment::Sky).then_some(SkyEnvironment::Sky {
                        gradient: view.cpu.gradient,
                        rotation_rad: view.cpu.rotation_rad,
                        intensity: view.cpu.intensity,
                    }),
                    aging: view.studio.aging.clone(),
                    adaptive: view.studio.adaptive,
                    denoise: view.studio.denoise,
                    path: options.path,
                    lens: view.studio.lens_enabled.then_some(view.studio.lens),
                    output: studio::cpu_output(view),
                    budget: options.budget,
                    primary_samples: options.primary_samples,
                    progressive: options.progressive,
                    preset: options.preset,
                    lights: options.lights.clone(),
                    punctual_lights: options.punctual_lights.clone(),
                    area_lights: options.area_lights.clone(),
                    area_samples: options.area_samples,
                    seed: options.seed,
                    shadows: options.shadows,
                    environment: match view.cpu.environment {
                        cpu::Environment::Constant => Some(RaytraceEnvironmentOptions { color: view.cpu.color, intensity: view.cpu.intensity }),
                        cpu::Environment::Hdr | cpu::Environment::Sky => None,
                        cpu::Environment::None => options.environment,
                    },
                    hdr: if view.cpu.environment == cpu::Environment::Hdr {
                        Some(CpuHdrEnvironment {
                            resource: view.cpu.hdr.resource().ok_or_else(|| app.tr("render.hdr_inspect_required").to_string())?,
                            rotation_rad: view.cpu.rotation_rad,
                            intensity: view.cpu.intensity,
                            samples: view.cpu.samples,
                        })
                    } else {
                        None
                    },
                }),
            }
        }
        ImageMethod::GpuRaytrace => {
            let studio = &view.studio;
            RenderJob::GpuPath {
                transparent_background: view.transparent,
                options: Box::new(GpuJob {
                    caustics: studio.caustics,
                    samples: view.samples,
                    max_depth: view.max_depth,
                    seed: view.seed,
                    aging: studio.aging.clone(),
                    nested_media: studio.nested_media,
                    volume: studio.volume,
                    adaptive: studio.adaptive,
                    transmission_samples: studio.transmission_samples,
                    finishing: studio.finishing,
                    backdrop: studio.backdrop_enabled.then_some(studio.backdrop),
                    linear_exr: studio.linear_exr,
                    tone_map: studio.tone_map,
                    denoise: studio.denoise,
                    lens: studio.lens_enabled.then_some(studio.lens),
                    lighting: if studio.lighting_enabled {
                        Some(StudioLighting {
                            punctual_lights: studio.punctual_lights,
                            directional_lights: studio.directional_lights,
                            environment: studio.ambient,
                            sun: studio.sun_enabled.then_some(studio.sun),
                            area_lights: AreaLights::new(&studio.area_lights).map_err(|error| error.to_string())?,
                        })
                    } else {
                        None
                    },
                    environment: if studio.environment == studio::Environment::Sky {
                        Some(SkyEnvironment::Sky { gradient: studio.gradient, rotation_rad: studio.rotation_rad, intensity: studio.intensity })
                    } else {
                        None
                    },
                    hdr: if studio.environment == studio::Environment::Hdr {
                        Some(GpuHdrEnvironment {
                            resource: studio.hdr.resource().ok_or_else(|| app.tr("render.hdr_inspect_required").to_string())?,
                            rotation_rad: studio.rotation_rad,
                            intensity: studio.intensity,
                            assume_linear_srgb: studio.assume_linear_srgb,
                        })
                    } else {
                        None
                    },
                }),
            }
        }
    });
    Ok(setup)
}

/// Save only fields a numerical editor changed. Navigation keeps its explicit
/// Update shot/Revert flow, and temporary optical bindings remain local.
pub(super) fn persist_editor(app: &mut SolveApp, before: &RenderSetup) -> Result<(), String> {
    let after = draft(app)?;
    // A corrective edit (for example removing an invalid wear layer) must not
    // require the hostile previous draft to be serialisable. The new value and
    // the saved command are still validated normally.
    let old = serde_json::to_value(before).ok();
    let new = serde_json::to_value(&after).map_err(|error| error.to_string())?;
    let saved = app.session.doc.render.setups.get(&app.render_workspace.view.name);
    let creating = saved.is_none();
    let saved = saved.and_then(|setup| serde_json::to_value(setup).ok());
    let mut patch = serde_json::Map::new();
    if let Some(fields) = new.as_object() {
        for (key, value) in fields {
            if key != "camera"
                && old.as_ref().and_then(|old| old.get(key)) != Some(value)
                && saved.as_ref().and_then(|saved| saved.get(key)) != Some(value)
            {
                patch.insert(key.clone(), value.clone());
            }
        }
    }
    if !patch.is_empty() {
        // The engine creates missing setups from its legacy defaults. On the first real
        // numerical edit, preserve the whole visible numerical baseline, including image
        // size and method; a job-only patch can be inadmissible at the engine's default size.
        // Navigation keeps its explicit Update shot policy. Merely revealing an editor is
        // still read-only because an actual edit must have populated the patch first.
        if creating && let Some(fields) = new.as_object() {
            patch = fields.iter().filter(|(key, _)| key.as_str() != "camera").map(|(key, value)| (key.clone(), value.clone())).collect();
        }
        after.validate().map_err(|error| error.to_string())?;
        let name = app.render_workspace.view.name.clone();
        app.run("render.settings.set", serde_json::json!({"name":name,"set":patch}))?;
        app.render_workspace.revision = app.session.revision;
        let camera = app.render_workspace.view.clean_setup.as_ref().map_or(after.camera, |clean| clean.camera);
        app.render_workspace.view.clean_setup = Some(RenderSetup { camera, ..after.clone() });
        app.render_workspace.view.clean_persisted = true;
        app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
        materials::refresh_render_revision(app);
        cpu::refresh_render_revision(app);
    }
    if let Some(saved) = app.session.doc.render.setups.get(&app.render_workspace.view.name) {
        if let Some(RenderJob::CpuRaytrace { options, .. }) = &saved.job {
            app.render_workspace.view.raytrace.output = options.output.clone();
            app.render_workspace.view.raytrace.denoise = options.denoise;
            app.render_workspace.view.raytrace.lens = options.lens;
            app.render_workspace.view.raytrace.path = options.path;
            app.render_workspace.view.raytrace.volume = options.volume;
        }
        let mut saved = saved.clone();
        saved.camera = after.camera;
        if saved == after {
            let camera = app.render_workspace.view.clean_setup.as_ref().map_or(after.camera, |clean| clean.camera);
            app.render_workspace.view.clean_setup = Some(RenderSetup { camera, ..after });
            app.render_workspace.view.clean_persisted = true;
            app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
            app.render_workspace.revision = app.session.revision;
        }
    }
    refresh_dirty(app);
    Ok(())
}

/// A missing setup uses the same transient baseline for initial loading and later model edits.
/// Existing entries, including a legacy job-less setup, retain their saved interpretation.
fn saved_or_initial(app: &SolveApp) -> RenderSetup {
    app.session.doc.render.setups.get(&app.render_workspace.view.name).cloned().unwrap_or_else(|| {
        let mut setup = RenderSetup::default();
        // Only a new, unsaved setup adopts the useful native image route. Discovery is read-only;
        // saved Raster, fixed CPU and legacy job-less setups keep their exact interpretation.
        if !app.preferences.render_legacy_image_defaults && super::image_host(app, ImageMethod::CpuRaytrace).is_ok() {
            setup.job = Some(RenderJob::CpuRaytrace {
                transparent_background: false,
                options: Box::new(CpuJob { progressive: Some(Default::default()), ..Default::default() }),
            });
        }
        setup
    })
}

/// A setup switch/reload replaces its numeric editor draft, never a completed image or camera.
pub(super) fn load(app: &mut SolveApp) {
    let persisted = app.session.doc.render.setups.contains_key(&app.render_workspace.view.name);
    let setup = saved_or_initial(app);
    load_values(&mut app.render_workspace.view, setup);
    app.render_workspace.view.dirty = false;
    app.render_workspace.revision = app.session.revision;
    // Keep the explicit Restore Saved Camera action: loading options does not navigate.
    app.render_workspace.view.clean_setup = draft(app).ok();
    app.render_workspace.view.clean_persisted = persisted;
    app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
    super::light::loaded(app);
}

fn load_values(view: &mut super::ViewState, setup: RenderSetup) {
    view.method = ImageMethod::Raster;
    view.transparent = false;
    view.raytrace = RaytraceOptions::default();
    view.cpu_sampling_initialized = false;
    view.cpu = cpu::View::default();
    view.samples = 64;
    view.max_depth = 8;
    view.seed = 0;
    view.studio = studio::View::default();
    view.materials = materials::View::default();
    match &setup.job {
        Some(RenderJob::Raster { transparent_background }) => view.transparent = *transparent_background,
        Some(RenderJob::CpuRaytrace { options, transparent_background }) => {
            view.method = ImageMethod::CpuRaytrace;
            view.transparent = *transparent_background;
            view.cpu_sampling_initialized = true;
            view.studio.volume = options.volume;
            view.studio.denoise = options.denoise;
            view.studio.aging = options.aging.clone();
            view.studio.adaptive = options.adaptive;
            view.studio.sun_enabled = options.sun.is_some();
            if let Some(sun) = options.sun {
                view.studio.sun = sun;
                view.studio.lighting_enabled = true;
            }
            view.studio.caustics = options.caustics;
            view.raytrace = RaytraceOptions {
                caustics: options.caustics,
                sun: options.sun.map(Box::new),
                volume: options.volume,
                adaptive: options.adaptive.map(Box::new),
                denoise: options.denoise,
                path: options.path,
                lens: options.lens,
                output: options.output.clone(),
                budget: options.budget,
                primary_samples: options.primary_samples,
                progressive: options.progressive,
                preset: options.preset,
                lights: options.lights.clone(),
                punctual_lights: options.punctual_lights.clone(),
                area_lights: options.area_lights.clone(),
                area_samples: options.area_samples,
                seed: options.seed,
                shadows: options.shadows,
                ..Default::default()
            };
            if let Some(lens) = options.lens {
                view.studio.lens_enabled = true;
                view.studio.lens = lens;
            }
            if let Some(output) = &options.output {
                view.studio.tone_map = output.tone_map;
                view.studio.finishing = output.finishing;
                view.studio.backdrop_enabled = output.backdrop.is_some();
                view.studio.backdrop = output.backdrop.unwrap_or_default();
                view.studio.linear_exr = output.linear_exr;
            }
            if let Some(SkyEnvironment::Sky { gradient, rotation_rad, intensity }) = options.sky {
                view.cpu.environment = cpu::Environment::Sky;
                view.cpu.gradient = gradient;
                view.cpu.rotation_rad = rotation_rad;
                view.cpu.intensity = intensity;
            }
            if let Some(environment) = options.environment {
                view.cpu.environment = cpu::Environment::Constant;
                view.cpu.color = environment.color;
                view.cpu.intensity = environment.intensity;
            }
            if let Some(environment) = options.hdr {
                view.cpu.environment = cpu::Environment::Hdr;
                view.cpu.hdr = hdr::Input::EmbeddedResource { resource: environment.resource };
                view.cpu.rotation_rad = environment.rotation_rad;
                view.cpu.intensity = environment.intensity;
                view.cpu.samples = environment.samples;
            }
        }
        Some(RenderJob::GpuPath { transparent_background, options }) => {
            view.method = ImageMethod::GpuRaytrace;
            view.transparent = *transparent_background;
            view.samples = options.samples;
            view.max_depth = options.max_depth;
            view.seed = options.seed;
            view.studio.aging = options.aging.clone();
            view.studio.caustics = options.caustics;
            view.studio.nested_media = options.nested_media;
            view.studio.volume = options.volume;
            view.studio.adaptive = options.adaptive;
            view.studio.transmission_samples = options.transmission_samples;
            view.studio.finishing = options.finishing;
            view.studio.backdrop_enabled = options.backdrop.is_some();
            view.studio.backdrop = options.backdrop.unwrap_or_default();
            view.studio.linear_exr = options.linear_exr;
            view.studio.tone_map = options.tone_map;
            view.studio.denoise = options.denoise;
            if let Some(lens) = options.lens {
                view.studio.lens_enabled = true;
                view.studio.lens = lens;
            }
            if let Some(lighting) = options.lighting {
                view.studio.lighting_enabled = true;
                view.studio.ambient = lighting.environment;
                view.studio.sun_enabled = lighting.sun.is_some();
                if let Some(sun) = lighting.sun {
                    view.studio.sun = sun;
                }
                view.studio.area_lights = lighting.area_lights.iter().copied().collect();
                view.studio.directional_lights = lighting.directional_lights;
                view.studio.punctual_lights = lighting.punctual_lights;
            }
            if let Some(SkyEnvironment::Sky { gradient, rotation_rad, intensity }) = &options.environment {
                view.studio.environment = studio::Environment::Sky;
                view.studio.gradient = *gradient;
                view.studio.rotation_rad = *rotation_rad;
                view.studio.intensity = *intensity;
            }
            if let Some(environment) = options.hdr {
                view.studio.environment = studio::Environment::Hdr;
                view.studio.hdr = hdr::Input::EmbeddedResource { resource: environment.resource };
                view.studio.rotation_rad = environment.rotation_rad;
                view.studio.intensity = environment.intensity;
                view.studio.assume_linear_srgb = environment.assume_linear_srgb;
            }
        }
        None => {}
    }
    view.draft = setup;
}

/// Compare the complete authoring source, excluding only saved Render settings.
/// Stable body labels alone do not prove that geometry or its material is unchanged.
pub(super) fn same_model_source(app: &SolveApp, document: &std::sync::Weak<solidcraft_engine::doc::Document>) -> bool {
    if app.session.model.is_stale() {
        return false;
    }
    let Some(source) = document.upgrade() else {
        return false;
    };
    // Exhaustive by design: adding a Document field must update this comparison.
    // Match ergonomics bind references, including vectors and point-cloud data.
    macro_rules! compare_authoring_fields {
        ($($field:ident),* $(,)?) => {{
            let solidcraft_engine::doc::Document { render: _, $($field),* } = source.as_ref();
            true $(&& $field == &app.session.doc.$field)*
        }};
    }
    compare_authoring_fields!(
        newer_file,
        format,
        format_pending,
        name,
        units,
        metadata,
        params,
        text_params,
        features,
        marker,
        next_id,
        reserved_body_names,
        components,
        next_component_color_index,
        occurrences,
        assembly,
        sheet,
        plastic,
        parts,
        links,
        configs,
        favorites,
        canvases,
        point_clouds,
        param_comments,
        materials,
        print_faces,
        user_materials,
        appearances,
        body_components,
        body_offsets,
        browser_groups,
        timeline_groups,
        browser_order,
        named_views,
        visibility,
    )
}

/// A single refresh's source comparisons. Targets are still checked per binding.
#[derive(Default)]
pub(super) struct SourceCache(Vec<(std::sync::Weak<solidcraft_engine::doc::Document>, bool)>);

impl SourceCache {
    pub(super) fn same_model_source(&mut self, app: &SolveApp, document: &std::sync::Weak<solidcraft_engine::doc::Document>) -> bool {
        if let Some((_, same)) = self.0.iter().find(|(source, _)| std::sync::Weak::ptr_eq(source, document)) {
            return *same && !app.session.model.is_stale() && document.upgrade().is_some();
        }
        let same = same_model_source(app, document);
        self.0.push((document.clone(), same));
        same
    }
}

/// Synchronize saved edits/Undo without replacing local camera or runtime inputs.
pub(super) fn sync_revision(app: &mut SolveApp) {
    if app.render_workspace.revision == app.session.revision {
        return;
    }
    // A new shot name can intentionally carry the unsaved draft of its source.
    // Its missing saved entry is not an Undo of that source's numerical fields.
    if app.render_workspace.view.clean_name != app.render_workspace.view.name {
        if !app.render_workspace.view.dirty {
            load(app);
        }
        return;
    }
    let Some(clean) = app.render_workspace.view.clean_setup.clone() else {
        if !app.render_workspace.view.dirty {
            load(app);
        }
        return;
    };
    let persisted = app.session.doc.render.setups.contains_key(&app.render_workspace.view.name);
    let saved = app.session.doc.render.setups.get(&app.render_workspace.view.name).cloned().unwrap_or_else(|| {
        // An active unsaved setup keeps the baseline captured when it was opened. A missing
        // entry after Undo of a saved setup, however, returns to the current initial defaults.
        if app.render_workspace.view.clean_persisted { saved_or_initial(app) } else { clean.clone() }
    });
    let mut previous = super::ViewState::default();
    load_values(&mut previous, clean.clone());
    let mut updated = super::ViewState::default();
    load_values(&mut updated, saved);
    // Construct the new clean numerical baseline independently of local drafts.
    let current = std::mem::replace(&mut app.render_workspace.view, updated);
    let mut next_clean = draft(app).ok();
    if let Some(next) = &mut next_clean {
        next.camera = clean.camera;
    }
    let updated = std::mem::replace(&mut app.render_workspace.view, current);
    let view = &mut app.render_workspace.view;
    macro_rules! sync {
        ($($head:ident $(.$tail:ident)*),* $(,)?) => {$(
            if previous.$head$(.$tail)* != updated.$head$(.$tail)* && view.$head$(.$tail)* == previous.$head$(.$tail)* {
                view.$head$(.$tail)* = updated.$head$(.$tail)*;
            }
        )*};
    }
    // Only persisted fields participate. Reflections, optical bindings, file selectors,
    // editor selection, results and host/job state stay in their existing owners.
    sync!(
        method,
        cpu_sampling_initialized,
        transparent,
        samples,
        max_depth,
        seed,
        draft.backend,
        draft.mode,
        draft.width,
        draft.height,
        draft.format,
        draft.exposure_ev,
        draft.environment_rotation,
        draft.environment_intensity,
        draft.background,
        draft.job,
        draft.surfaces,
        draft.optics,
        draft.coats,
        draft.stage,
        raytrace.budget,
        raytrace.denoise,
        raytrace.output,
        raytrace.lens,
        raytrace.path,
        raytrace.caustics,
        raytrace.sun,
        raytrace.sky,
        raytrace.volume,
        raytrace.primary_samples,
        raytrace.progressive,
        raytrace.adaptive,
        raytrace.preset,
        raytrace.lights,
        raytrace.punctual_lights,
        raytrace.area_lights,
        raytrace.area_samples,
        raytrace.seed,
        raytrace.shadows,
        cpu.environment,
        cpu.color,
        cpu.gradient,
        cpu.intensity,
        cpu.rotation_rad,
        cpu.samples,
        studio.aging,
        studio.nested_media,
        studio.caustics,
        studio.volume,
        studio.adaptive,
        studio.transmission_samples,
        studio.finishing,
        studio.backdrop_enabled,
        studio.backdrop,
        studio.linear_exr,
        studio.tone_map,
        studio.denoise,
        studio.lens_enabled,
        studio.lens,
        studio.lighting_enabled,
        studio.ambient,
        studio.sun_enabled,
        studio.sun,
        studio.area_lights,
        studio.directional_lights,
        studio.punctual_lights,
        studio.environment,
        studio.gradient,
        studio.rotation_rad,
        studio.intensity,
        studio.assume_linear_srgb
    );
    // File HDR selectors are runtime inputs; embedded selectors follow saved Undo.
    if view.cpu.hdr == previous.cpu.hdr {
        view.cpu.hdr = updated.cpu.hdr;
    }
    if view.studio.hdr == previous.studio.hdr {
        view.studio.hdr = updated.studio.hdr;
    }
    view.clean_setup = next_clean;
    view.clean_persisted = persisted;
    app.render_workspace.revision = app.session.revision;
    materials::refresh_render_revision(app);
    cpu::refresh_render_revision(app);
    super::light::loaded(app);
    refresh_dirty(app);
}

pub(super) fn refresh_dirty(app: &mut SolveApp) {
    if let Some(clean) = &app.render_workspace.view.clean_setup {
        app.render_workspace.view.dirty = has_runtime_inputs(app) || draft(app).as_ref() != Ok(clean);
    }
}

pub(super) fn save(app: &mut SolveApp) -> Result<(), String> {
    save_with_camera(app, true)
}

/// Numerical source edits capture bytes/intent atomically without updating the shot camera.
pub(super) fn save_numerical(app: &mut SolveApp) -> Result<(), String> {
    save_with_camera(app, false)
}

fn setup_patch(setup: RenderSetup, save_camera: bool) -> Result<serde_json::Value, String> {
    let mut value = serde_json::to_value(setup).map_err(|error| error.to_string())?;
    if !save_camera && let Some(fields) = value.as_object_mut() {
        fields.remove("camera");
    }
    Ok(value)
}

/// Numeric reloads keep both the live camera and its previous dirty baseline.
pub(super) fn reload_numerical(app: &mut SolveApp) {
    let camera = app.render_workspace.view.clean_setup.as_ref().map(|clean| clean.camera);
    load(app);
    if let Some(camera) = camera
        && let Some(clean) = &mut app.render_workspace.view.clean_setup
    {
        clean.camera = camera;
    }
    refresh_dirty(app);
}

fn save_with_camera(app: &mut SolveApp, save_camera: bool) -> Result<(), String> {
    let clean_camera = app.render_workspace.view.clean_setup.as_ref().map_or(app.cam, |clean| clean.camera);
    let mut setup = snapshot(app)?;
    let name = app.render_workspace.view.name.clone();
    let capture = hdr::active(app).and_then(|target| match hdr::input(app, target) {
        hdr::Input::FileCaptured { path, metadata } => Some((target, path.clone(), metadata.sha256)),
        _ => None,
    });
    if let Some((_, path, digest)) = &capture {
        let mut params = serde_json::json!({"name":name,"path":path,"expected_sha256":digest});
        match &mut setup.job {
            Some(RenderJob::CpuRaytrace { options, .. }) => {
                let environment = options.hdr.take().ok_or_else(|| app.tr("render.hdr_inspect_required").to_string())?;
                params["rotation_rad"] = serde_json::json!(environment.rotation_rad);
                params["intensity"] = serde_json::json!(environment.intensity);
                params["samples"] = serde_json::json!(environment.samples);
            }
            Some(RenderJob::GpuPath { options, .. }) => {
                let environment = options.hdr.take().ok_or_else(|| app.tr("render.hdr_inspect_required").to_string())?;
                params["rotation_rad"] = serde_json::json!(environment.rotation_rad);
                params["intensity"] = serde_json::json!(environment.intensity);
                params["assume_linear_srgb"] = serde_json::json!(environment.assume_linear_srgb);
            }
            _ => return Err(app.tr("render.hdr_inspect_required").to_string()),
        }
        params["set"] = setup_patch(setup, save_camera)?;
        // The expected digest rejects an externally changed file before any resource/setup edit.
        app.run("render.settings.capture_hdr", params)?;
    } else {
        app.run("render.settings.set", serde_json::json!({"name":name,"set":setup_patch(setup, save_camera)?}))?;
    }
    let setup = app.session.doc.render.setups.get(&name).cloned().ok_or_else(|| app.tr("render.setup_save_missing").to_string())?;
    if let Some((target, _, resource)) = capture {
        match target {
            hdr::Target::Cpu => app.render_workspace.view.cpu.hdr = hdr::Input::EmbeddedResource { resource },
            hdr::Target::Gpu => app.render_workspace.view.studio.hdr = hdr::Input::EmbeddedResource { resource },
        }
    }
    if let Some(RenderJob::CpuRaytrace { options, .. }) = &setup.job {
        app.render_workspace.view.raytrace.output = options.output.clone();
        app.render_workspace.view.raytrace.denoise = options.denoise;
        app.render_workspace.view.raytrace.lens = options.lens;
        app.render_workspace.view.raytrace.path = options.path;
        app.render_workspace.view.raytrace.volume = options.volume;
    }
    app.render_workspace.view.draft = setup.clone();
    app.render_workspace.view.clean_setup = Some(if save_camera { setup } else { RenderSetup { camera: clean_camera, ..setup } });
    app.render_workspace.view.clean_persisted = true;
    app.render_workspace.view.clean_name = app.render_workspace.view.name.clone();
    app.render_workspace.view.dirty = false;
    app.render_workspace.revision = app.session.revision;
    if !save_camera {
        refresh_dirty(app);
    }
    Ok(())
}