Skip to content

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

20.7 KB
Raw Blame
//! GPU studio editors. Numeric intent is portable; HDR resources cross the engine capture boundary.
use serde_json::{Value, json};
use solidcraft_engine::render::job::{AreaLight, AreaLights, DirectionalLights, PunctualLights, StudioLighting, Sun, ThinLens, ToneMap};
use solidcraft_engine::render::lighting::environment::SkyGradient;

use super::hdr;
use crate::{SolveApp, ui_kit};

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(super) enum Environment {
    #[default]
    None,
    Sky,
    Hdr,
}

#[derive(Clone, Debug)]
pub(super) struct View {
    pub caustics: Option<solidcraft_engine::render::job::CausticOptions>,
    pub aging: solidcraft_engine::doc::render_aging::SavedAgingStack,
    pub nested_media: bool,
    pub volume: Option<solidcraft_engine::render::job::volume::HomogeneousVolume>,
    pub adaptive: Option<solidcraft_engine::render::job::adaptive::AdaptiveSampling>,
    pub transmission_samples: u32,
    pub finishing: solidcraft_engine::render::job::finishing::Finishing,
    pub backdrop_enabled: bool,
    pub backdrop: solidcraft_engine::render::job::finishing::Backdrop,
    pub linear_exr: bool,
    pub export_exr: bool,
    pub tone_map: ToneMap,
    pub denoise: bool,
    pub lens_enabled: bool,
    pub lens: ThinLens,
    pub environment: Environment,
    pub hdr: hdr::Input,
    pub assume_linear_srgb: bool,
    pub rotation_rad: f64,
    pub gradient: SkyGradient,
    pub intensity: f64,
    pub lighting_enabled: bool,
    pub ambient: [f64; 3],
    pub sun_enabled: bool,
    pub sun: Sun,
    pub area_lights: Vec<AreaLight>,
    pub directional_lights: DirectionalLights,
    pub punctual_lights: PunctualLights,
}

impl Default for View {
    fn default() -> Self {
        Self {
            caustics: None,
            aging: Default::default(),
            nested_media: false,
            volume: None,
            adaptive: None,
            transmission_samples: 1,
            finishing: Default::default(),
            backdrop_enabled: false,
            backdrop: Default::default(),
            linear_exr: false,
            export_exr: false,
            tone_map: ToneMap::Reinhard,
            denoise: false,
            lens_enabled: false,
            lens: ThinLens { aperture_radius_mm: 1.0, focus_distance_mm: 100.0 },
            environment: Environment::None,
            hdr: hdr::Input::default(),
            assume_linear_srgb: false,
            rotation_rad: 0.0,
            gradient: SkyGradient::default(),
            intensity: 1.0,
            lighting_enabled: false,
            ambient: [0.5; 3],
            sun_enabled: false,
            sun: Sun { direction: [-0.4, -0.6, 0.7], angular_radius_rad: 0.02, radiance: [1000.0, 950.0, 850.0] },
            area_lights: Vec::new(),
            directional_lights: Default::default(),
            punctual_lights: Default::default(),
        }
    }
}

/// CPU and GPU editors share presentation intent; CPU transport options remain independent.
/// Preserve an explicitly saved identity object instead of erasing it on an unedited reload.
pub(super) fn cpu_output(view: &super::ViewState) -> Option<Box<solidcraft_engine::render::job::OutputOptions>> {
    let settings = solidcraft_engine::render::job::OutputOptions {
        tone_map: view.studio.tone_map,
        finishing: view.studio.finishing,
        backdrop: view.studio.backdrop_enabled.then_some(view.studio.backdrop),
        linear_exr: view.studio.linear_exr,
    };
    if settings == Default::default() && view.raytrace.output.is_none() { None } else { Some(Box::new(settings)) }
}

pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> {
    let view = &app.render_workspace.view.studio;
    params["tone_map"] = json!(view.tone_map);
    params["denoise"] = json!(view.denoise);
    params["finishing"] = json!(view.finishing);
    params["backdrop"] = json!(view.backdrop_enabled.then_some(view.backdrop));
    params["linear_exr"] = json!(view.linear_exr);
    params["aging"] = json!(view.aging);
    params["nested_media"] = json!(view.nested_media);
    params["caustics"] = json!(view.caustics);
    params["volume"] = json!(view.volume);
    params["adaptive"] = json!(view.adaptive);
    params["transmission_samples"] = json!(view.transmission_samples);
    if view.lens_enabled {
        view.lens.validate().map_err(|error| error.to_string())?;
        if view.lens.aperture_radius_mm > 0.0 && app.cam.fov == 0.0 {
            return Err(app.tr("render.studio_lens_perspective").to_string());
        }
        params["lens"] = json!(view.lens);
    }
    if view.lighting_enabled {
        let lighting = StudioLighting {
            punctual_lights: view.punctual_lights,
            directional_lights: view.directional_lights,
            environment: view.ambient,
            sun: view.sun_enabled.then_some(view.sun),
            area_lights: AreaLights::new(&view.area_lights).map_err(|error| error.to_string())?,
        };
        lighting.validate().map_err(|error| error.to_string())?;
        params["lighting"] = json!(lighting);
    }
    if view.environment != Environment::None {
        if !view.intensity.is_finite() || !(0.0..=100.0).contains(&view.intensity) || !view.rotation_rad.is_finite() || view.rotation_rad.abs() > 1e6
        {
            return Err(app.tr("render.studio_environment_bounds").to_string());
        }
        let mut environment = json!({"kind":"sky","rotation_rad":view.rotation_rad,"intensity":view.intensity});
        if view.environment == Environment::Hdr {
            environment = hdr::request(app, hdr::Target::Gpu)?;
            environment["rotation_rad"] = json!(view.rotation_rad);
            environment["intensity"] = json!(view.intensity);
            environment["assume_linear_srgb"] = json!(view.assume_linear_srgb);
        }
        if view.environment == Environment::Sky {
            environment["gradient"] = json!(view.gradient);
        }
        params["environment"] = environment;
    }
    Ok(())
}

pub(super) fn vector(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, speed: f64) {
    ui.label(label);
    ui.horizontal(|ui| {
        for component in value {
            ui_kit::number_field(ui, component, range.clone(), speed, "");
        }
    });
}

#[cfg(test)]
pub(super) fn finishing_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    super::transport::sampling_controls(app, ui);
    post_controls(app, ui);
    tone_controls(app, ui);
}
#[cfg(test)]
pub(super) fn tone_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    ui_kit::text(ui, app.tr("render.studio_tone_map"), ui_kit::Text::Inline);
    let selected = app.render_workspace.view.studio.tone_map;
    let label = match selected {
        ToneMap::Reinhard => crate::i18n::tr("render.tone_reinhard"),
        ToneMap::AcesFitted => crate::i18n::tr("render.tone_aces_fitted"),
    };
    let response = ui_kit::dropdown_menu(ui, "render_tone_map", label, |ui| {
        for (map, label) in
            [(ToneMap::Reinhard, crate::i18n::tr("render.tone_reinhard")), (ToneMap::AcesFitted, crate::i18n::tr("render.tone_aces_fitted"))]
        {
            if ui_kit::list_picker(ui, label, label, map == selected).clicked() {
                app.render_workspace.view.studio.tone_map = map;
                ui.close();
            }
        }
    });
    crate::scenario::publish_target("render:tone-map", response.rect);
    let denoise = app.tr("render.studio_denoise").to_string();
    ui_kit::checkbox(ui, &denoise, &mut app.render_workspace.view.studio.denoise);
    if app.render_workspace.view.studio.denoise {
        ui.small(app.tr("render.studio_denoise_help"));
    }
}

#[cfg(test)]
pub(super) fn lens_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let lens = app.tr("render.studio_lens").to_string();
    ui_kit::checkbox(ui, &lens, &mut app.render_workspace.view.studio.lens_enabled);
    if app.render_workspace.view.studio.lens_enabled {
        ui.label(app.tr("render.studio_aperture"));
        ui_kit::number_field(ui, &mut app.render_workspace.view.studio.lens.aperture_radius_mm, 0.0..=1e7, 0.1, " mm");
        ui.label(app.tr("render.studio_focus"));
        ui_kit::number_field(ui, &mut app.render_workspace.view.studio.lens.focus_distance_mm, 1e-6..=1e9, 1.0, " mm");
    }
}

#[cfg(test)]
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    finishing_controls(app, ui);
    lens_controls(app, ui);
    let title = app.tr("render.studio_environment").to_string();
    ui_kit::section(ui, "render_environment", &title, false, |ui| environment_controls(app, ui));
    let title = app.tr("render.studio_lighting").to_string();
    ui_kit::section(ui, "render_studio_lighting", &title, false, |ui| lighting_controls(app, ui));
    ui.small(app.tr("render.studio_runtime_help"));
}

#[cfg(test)]
pub(super) fn environment_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    super::environment::atmosphere(app, ui);
    let variants =
        [(Environment::None, "render.studio_environment_none"), (Environment::Sky, "render.studio_sky"), (Environment::Hdr, "render.studio_hdr")];
    let selected = app.render_workspace.view.studio.environment;
    let key = match selected {
        Environment::None => "render.studio_environment_none",
        Environment::Sky => "render.studio_sky",
        Environment::Hdr => "render.studio_hdr",
    };
    let label = app.tr(key).to_string();
    ui_kit::dropdown_menu(ui, "render_environment_kind", &label, |ui| {
        for (value, key) in variants {
            if ui_kit::list_picker(ui, key, app.tr(key), value == selected).clicked() {
                app.render_workspace.view.studio.environment = value;
                ui.close();
            }
        }
    });
    if app.render_workspace.view.studio.environment == Environment::None {
        return;
    }
    if app.render_workspace.view.studio.environment == Environment::Hdr {
        hdr::controls(app, ui, hdr::Target::Gpu);
        let assume = app.tr("render.studio_hdr_srgb").to_string();
        ui_kit::checkbox(ui, &assume, &mut app.render_workspace.view.studio.assume_linear_srgb);
        ui.small(app.tr("render.studio_hdr_help"));
    } else {
        ui.small(app.tr("render.studio_sky_help"));
        for (index, key) in [(0, "render.sky_zenith"), (1, "render.sky_horizon"), (2, "render.sky_ground")] {
            let label = app.tr(key).to_string();
            let gradient = &mut app.render_workspace.view.studio.gradient;
            let field = match index {
                0 => &mut gradient.zenith,
                1 => &mut gradient.horizon,
                _ => &mut gradient.ground,
            };
            let mut editable = field.map(f64::from);
            let before = editable;
            vector(ui, &label, &mut editable, 0.0..=1e6, 0.01);
            if editable != before {
                *field = editable.map(|value| value as f32);
            }
        }
    }
    ui.label(app.tr("render.studio_intensity"));
    ui_kit::number_field(ui, &mut app.render_workspace.view.studio.intensity, 0.0..=100.0, 0.1, "");
    ui.label(app.tr("render.studio_rotation"));
    let mut degrees = app.render_workspace.view.studio.rotation_rad.to_degrees();
    if ui_kit::number_field(ui, &mut degrees, -1e6_f64.to_degrees()..=1e6_f64.to_degrees(), 1.0, "°").changed() {
        app.render_workspace.view.studio.rotation_rad = degrees.to_radians();
    }
}

#[cfg(test)]
pub(super) fn lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    super::light::lighting(app, ui);
}

/// Presentation is opt-in; raw radiance and engineering appearance stay untouched.
#[cfg(test)]
pub(super) fn post_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let before = app.render_workspace.view.studio.finishing;
    bloom_controls(app, ui);
    grading_controls(app, ui);
    regrade_controls(app, ui);
    app.render_workspace.view.dirty |= before != app.render_workspace.view.studio.finishing;
}

#[cfg(test)]
pub(super) fn bloom_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let mut enabled = app.render_workspace.view.studio.finishing.bloom.is_some();
    let label = app.tr("render.bloom_enable").to_string();
    let toggle = ui_kit::checkbox(ui, &label, &mut enabled);
    crate::scenario::publish_target("render:bloom-enable", toggle.rect);
    if toggle.changed() {
        app.render_workspace.view.studio.finishing.bloom =
            enabled.then_some(solidcraft_engine::render::job::bloom::Bloom { strength: 0.15, ..Default::default() });
    }
    if enabled {
        for key in ["render.bloom_strength", "render.bloom_threshold", "render.bloom_radius"] {
            let label = app.tr(key).to_string();
            if let Some(bloom) = &mut app.render_workspace.view.studio.finishing.bloom {
                let response = ui_kit::row(ui, &label, |ui| match key {
                    "render.bloom_strength" => ui_kit::number_field(ui, &mut bloom.strength, 0.0..=2.0, 0.01, ""),
                    "render.bloom_threshold" => ui_kit::number_field(ui, &mut bloom.threshold, 0.0..=1e6, 0.05, ""),
                    _ => ui_kit::number_field(ui, &mut bloom.radius, 1..=64, 1.0, " px"),
                });
                crate::scenario::publish_target(key, response.rect);
            }
        }
        ui_kit::text(ui, app.tr("render.bloom_help"), ui_kit::Text::Note("render.bloom_help"));
        if app.render_workspace.view.transparent {
            ui_kit::text(ui, app.tr("render.bloom_opaque"), ui_kit::Text::Error("render.bloom_opaque"));
        }
    }
}

#[cfg(test)]
pub(super) fn grading_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let title = app.tr("render.output_grading").to_string();
    ui_kit::section(ui, "render_post_filters", &title, false, |ui| {
        ui_kit::text(ui, app.tr("render.post_help"), ui_kit::Text::Note("render.post_help"));
        for (channel, key) in ["render.post_gain_r", "render.post_gain_g", "render.post_gain_b"].into_iter().enumerate() {
            let label = app.tr(key).to_string();
            let Some(value) = app.render_workspace.view.studio.finishing.rgb_gain.get_mut(channel) else {
                continue;
            };
            let r = ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, value, 0.1..=8.0, 0.01, ""));
            crate::scenario::publish_target(key, r.rect);
        }
        for key in ["render.post_contrast", "render.post_saturation", "render.post_vignette"] {
            let label = app.tr(key).to_string();
            let finish = &mut app.render_workspace.view.studio.finishing;
            let (value, range) = match key {
                "render.post_contrast" => (&mut finish.contrast, 0.25..=4.0),
                "render.post_saturation" => (&mut finish.saturation, 0.0..=2.0),
                _ => (&mut finish.vignette, 0.0..=1.0),
            };
            let r = ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, value, range, 0.01, ""));
            crate::scenario::publish_target(key, r.rect);
        }
        let reset = ui_kit::button(ui, app.tr("render.post_reset"), ui_kit::Button::Normal);
        crate::scenario::publish_target("render:post-reset", reset.rect);
        if reset.clicked() {
            app.render_workspace.view.studio.finishing = Default::default();
        }
    });
}

#[cfg(test)]
pub(super) fn regrade_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    regrade_action(app, ui);
    retain_controls(app, ui);
}
pub(super) fn regrade_action(app: &mut SolveApp, ui: &mut egui::Ui) {
    let regrade = ui_kit::button(
        ui,
        app.tr("render.regrade_action"),
        ui_kit::Button::Enabled(super::ribbon::action_ready(app, "render.result.regrade").is_ok()),
    );
    crate::scenario::publish_target("render:regrade", regrade.rect);
    if regrade.clicked() {
        if let Err(error) = super::ribbon::perform_job(app, "render.result.regrade") {
            app.set_status(error, true);
        }
        ui.ctx().request_repaint();
    }
    ui_kit::text(ui, app.tr("render.regrade_help"), ui_kit::Text::Note("render.regrade_help"));
}
#[cfg(test)]
fn retain_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let label = app.tr("render.linear_retain").to_string();
    let r = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.studio.linear_exr);
    crate::scenario::publish_target("render:retain-exr", r.rect);
    app.render_workspace.view.dirty |= r.changed();
    if app.render_workspace.view.studio.linear_exr {
        ui_kit::text(ui, app.tr("render.linear_help"), ui_kit::Text::Note("render.linear_help"));
    }
}

#[cfg(test)]
pub(super) fn backdrop_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    use solidcraft_engine::render::job::finishing::BackdropMode;
    let label = app.tr("render.backdrop_enable").to_string();
    let r = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.studio.backdrop_enabled);
    crate::scenario::publish_target("render:backdrop-enabled", r.rect);
    app.render_workspace.view.dirty |= r.changed();
    if !app.render_workspace.view.studio.backdrop_enabled {
        return;
    }
    ui_kit::text(ui, app.tr("render.backdrop_help"), ui_kit::Text::Note("render.backdrop_help"));
    let before = app.render_workspace.view.studio.backdrop;
    let modes = [
        (BackdropMode::Vertical, "render.backdrop_vertical"),
        (BackdropMode::Horizontal, "render.backdrop_horizontal"),
        (BackdropMode::Radial, "render.backdrop_radial"),
    ];
    let current = app.render_workspace.view.studio.backdrop.mode;
    let key = modes.iter().find(|(m, _)| *m == current).map_or("render.backdrop_vertical", |(_, key)| *key);
    let label = app.tr(key).to_string();
    let r = ui_kit::dropdown_menu(ui, "render_backdrop_mode", &label, |ui| {
        for (mode, key) in modes {
            if ui_kit::list_picker(ui, key, app.tr(key), mode == current).clicked() {
                app.render_workspace.view.studio.backdrop.mode = mode;
                ui.close();
            }
        }
    });
    crate::scenario::publish_target("render:backdrop-mode", r.rect);
    for (first, key) in [(true, "render.backdrop_first"), (false, "render.backdrop_second")] {
        let label = app.tr(key).to_string();
        ui.label(label);
        let backdrop = &mut app.render_workspace.view.studio.backdrop;
        let color = if first { &mut backdrop.first_srgb } else { &mut backdrop.second_srgb };
        let r = ui_kit::color_field(ui, color);
        crate::scenario::publish_target(key, r.rect);
    }
    if current == BackdropMode::Radial {
        for (axis, key) in [(0, "render.backdrop_x"), (1, "render.backdrop_y")] {
            let label = app.tr(key).to_string();
            let Some(value) = app.render_workspace.view.studio.backdrop.center.get_mut(axis) else {
                continue;
            };
            ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, value, 0.0..=1.0, 0.01, ""));
        }
        let label = app.tr("render.backdrop_radius").to_string();
        ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.studio.backdrop.radius, 0.05..=4.0, 0.01, ""));
    }
    if app.render_workspace.view.transparent {
        ui_kit::text(ui, app.tr("render.backdrop_alpha_conflict"), ui_kit::Text::Error("render.backdrop_alpha_conflict"));
    }
    if before != app.render_workspace.view.studio.backdrop {
        app.render_workspace.view.dirty = true;
    }
}

pub(super) fn export_label(app: &SolveApp) -> &str {
    app.tr(if app.render_workspace.view.studio.export_exr { "render.export_linear" } else { "render.output_export" })
}

pub(super) fn export_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let label = app.tr("render.output_format").to_string();
    let response = ui_kit::row(ui, &label, |ui| format_choices(app, ui));
    crate::scenario::publish_target("render:export-format", response.rect);
}
pub(super) fn format_choices(app: &mut SolveApp, ui: &mut egui::Ui) -> egui::Response {
    let available = linear_export_available(app);
    ui.scope(|ui| {
        let reason = app.tr("render.output_master_unavailable");
        let mut format = usize::from(app.render_workspace.view.studio.export_exr);
        if ui_kit::segmented(
            ui,
            &mut format,
            &["PNG", "EXR"],
            ui_kit::Segments {
                disabled_reasons: &[None, (!available).then_some(reason)],
                targets: &["render:format-png", "render:format-exr"],
                workspace_accent: true,
                intrinsic: true,
                compact: true,
                ..Default::default()
            },
        ) {
            app.render_workspace.view.studio.export_exr = format == 1;
        }
    })
    .response
}

pub(super) fn linear_export_available(app: &SolveApp) -> bool {
    app.render_workspace
        .view
        .completed
        .and_then(|job| app.session.render_job_handle(job).ok())
        .and_then(|handle| handle.frame().ok().flatten())
        .is_some_and(|frame| frame.linear_exr().is_some())
}