SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Selected-light editor and transient visibility. Saved settings are edited only by commands.
use super::{ImageMethod, RenderSelection, cpu, setups, studio};
use crate::ui_kit::BackingTooltipExt as _;
use crate::{SolveApp, ui_kit};
use serde_json::{Value, json};
use solidcraft_engine::doc::render_settings::{CpuJob, GpuJob, RenderJob, RenderSetup, SkyEnvironment};
use solidcraft_engine::geom::prelude::*;
use solidcraft_engine::render::job::{AreaLights, StudioLighting};
use solidcraft_engine::schema::render_lights::{Geometry, Light, LightIdRemap, Visibility};
#[derive(Clone, Debug, Default)]
pub(super) struct View {
pub visibility: Visibility,
scope: String,
aim: Option<[f64; 3]>,
draft: Option<Draft>,
review: Option<Review>,
source: Option<Source>,
numeric_history: Option<NumericHistory>,
}
#[derive(Clone, Debug)]
struct Source {
settings: std::sync::Weak<solidcraft_engine::doc::render_settings::RenderSettings>,
method: ImageMethod,
}
#[derive(Clone, Debug)]
struct NumericHistory {
before: std::sync::Weak<solidcraft_engine::doc::render_settings::RenderSettings>,
after: std::sync::Weak<solidcraft_engine::doc::render_settings::RenderSettings>,
}
impl NumericHistory {
fn connects(&self, a: &Source, b: &Source) -> bool {
a.method == b.method
&& ((self.before.ptr_eq(&a.settings) && self.after.ptr_eq(&b.settings))
|| (self.after.ptr_eq(&a.settings) && self.before.ptr_eq(&b.settings)))
}
}
#[derive(Clone, Debug)]
struct Review {
name: String,
source: RenderSetup,
setup: RenderSetup,
revision: u64,
document: std::sync::Weak<solidcraft_engine::doc::Document>,
consent: bool,
}
#[derive(Clone, Debug)]
struct Draft {
id: String,
revision: u64,
ev: f64,
temperature: f64,
softness: f64,
azimuth: f64,
elevation: f64,
distance: f64,
size: f64,
height: f64,
position: [f64; 3],
direction: [f64; 3],
u: [f64; 3],
v: [f64; 3],
radiance: [f64; 3],
reference: f64,
minimum: f64,
aim: [f64; 3],
emitted_axis: [f64; 3],
inner_angle: f64,
outer_angle: f64,
}
/// Lighting-only read snapshot also works with unsaved HDR paths and temporary bindings.
fn settings(app: &SolveApp) -> Result<RenderSetup, String> {
let view = &app.render_workspace.view;
let job = match view.method {
ImageMethod::Raster => RenderJob::Raster { transparent_background: false },
ImageMethod::CpuRaytrace => RenderJob::CpuRaytrace {
transparent_background: false,
options: Box::new(CpuJob {
budget: view.raytrace.budget,
sun: view.studio.sun_enabled.then_some(view.studio.sun),
path: view.raytrace.path,
progressive: view.raytrace.progressive,
primary_samples: view.raytrace.primary_samples,
shadows: view.raytrace.shadows,
lights: view.raytrace.lights.clone(),
preset: view.raytrace.preset,
punctual_lights: view.raytrace.punctual_lights.clone(),
area_lights: view.raytrace.area_lights.clone(),
..Default::default()
}),
},
ImageMethod::GpuRaytrace => RenderJob::GpuPath {
transparent_background: false,
options: Box::new(GpuJob {
lighting: if view.studio.lighting_enabled {
Some(StudioLighting {
punctual_lights: view.studio.punctual_lights,
directional_lights: view.studio.directional_lights,
sun: view.studio.sun_enabled.then_some(view.studio.sun),
environment: view.studio.ambient,
area_lights: AreaLights::new(&view.studio.area_lights).map_err(|e| e.to_string())?,
})
} else {
None
},
// Environment illumination suppresses the legacy analytic studio; its bytes are not needed here.
environment: (view.studio.environment != studio::Environment::None).then_some(SkyEnvironment::Sky {
gradient: Default::default(),
rotation_rad: 0.0,
intensity: 1.0,
}),
..Default::default()
}),
},
};
Ok(RenderSetup { camera: app.cam, width: 1, height: 1, job: Some(job), ..Default::default() })
}
/// Copy the common analytic rig without inventing a backend's implicit studio.
/// This is a pure prospective conversion; the caller publishes only after full validation.
pub(super) fn celestial_method(app: &SolveApp, next: &mut super::ViewState, method: ImageMethod) -> Result<(), String> {
let sources = rows(app)?;
let mut setup = RenderSetup {
camera: app.cam,
width: 1,
height: 1,
job: Some(match method {
ImageMethod::CpuRaytrace => RenderJob::CpuRaytrace {
transparent_background: false,
options: Box::new(CpuJob {
budget: next.raytrace.budget,
sun: next.studio.sun_enabled.then_some(next.studio.sun),
path: next.raytrace.path,
progressive: next.raytrace.progressive,
primary_samples: next.raytrace.primary_samples,
shadows: next.raytrace.shadows,
..Default::default()
}),
},
ImageMethod::GpuRaytrace => RenderJob::GpuPath {
transparent_background: false,
options: Box::new(GpuJob {
lighting: Some(StudioLighting { sun: next.studio.sun_enabled.then_some(next.studio.sun), ..Default::default() }),
..Default::default()
}),
},
ImageMethod::Raster => return Ok(()),
}),
..Default::default()
};
solidcraft_engine::render_lights::write(&mut setup, &sources)?;
let converted = solidcraft_engine::render_lights::inspect(&setup)?;
if sources.len() != converted.len()
|| sources.iter().any(|source| {
!converted.iter().any(|target| {
source.id == target.id
&& source.geometry.kind() == target.geometry.kind()
&& matches!(source.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. })
== matches!(target.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. })
})
})
{
return Err(app.tr("render.cpu_celestial_switch").into());
}
match setup.job {
Some(RenderJob::CpuRaytrace { options, .. }) => {
next.raytrace.sun = options.sun.map(Box::new);
next.studio.sun_enabled = options.sun.is_some();
if let Some(sun) = options.sun {
next.studio.sun = sun;
}
next.raytrace.preset = options.preset;
next.raytrace.lights = options.lights;
next.raytrace.punctual_lights = options.punctual_lights;
next.raytrace.area_lights = options.area_lights;
}
Some(RenderJob::GpuPath { options, .. }) => {
if let Some(lighting) = options.lighting {
next.studio.lighting_enabled = true;
next.studio.directional_lights = lighting.directional_lights;
next.studio.punctual_lights = lighting.punctual_lights;
next.studio.area_lights = lighting.area_lights.iter().copied().collect();
next.studio.sun_enabled = lighting.sun.is_some();
if let Some(sun) = lighting.sun {
next.studio.sun = sun;
}
}
}
_ => return Err(app.tr("render.cpu_celestial_switch").into()),
}
Ok(())
}
/// The caller has just executed celestial_method's address-preserving conversion.
/// Preserve transient visibility only when its prior Arc/method source is proven;
/// equal row values or counts alone never establish identity.
pub(super) fn celestial_method_applied(
app: &mut SolveApp,
before: &std::sync::Weak<solidcraft_engine::doc::render_settings::RenderSettings>,
method: ImageMethod,
) {
let valid = app.render_workspace.view.lights.scope == app.render_workspace.view.name
&& app.render_workspace.view.lights.source.as_ref().is_some_and(|source| source.method == method && source.settings.ptr_eq(before));
let source = Source { settings: std::sync::Arc::downgrade(&app.session.doc.render), method: app.render_workspace.view.method };
let scope = app.render_workspace.view.name.clone();
let view = &mut app.render_workspace.view.lights;
view.scope = scope;
view.source = Some(source);
view.numeric_history = None;
view.draft = None;
if !valid {
view.visibility = Visibility::default();
if matches!(app.render_workspace.view.selection, RenderSelection::Light(_)) {
app.render_workspace.view.selection = RenderSelection::Nothing;
}
}
}
pub(super) fn rows(app: &SolveApp) -> Result<Vec<Light>, String> {
solidcraft_engine::render_lights::inspect(&settings(app)?)
}
pub(super) fn name(app: &SolveApp, light: &Light) -> String {
if light.number <= 3 { app.tr(&light.name_key).into() } else { crate::i18n::format(&light.name_key, &[("number", &light.number.to_string())]) }
}
/// A known volume-only/transport adoption preserves the analytic rig's addresses.
/// Equal values alone are insufficient: prove both the cached pre-command Arc
/// and its saved rows, then retain only this one exact Undo/Redo edge.
pub(super) fn volume_edited(
app: &mut SolveApp,
before: &std::sync::Weak<solidcraft_engine::doc::render_settings::RenderSettings>,
method: ImageMethod,
draft: &RenderSetup,
rig: &[Light],
) {
let valid = app.render_workspace.view.method == method
&& app.render_workspace.view.lights.scope == app.render_workspace.view.name
&& app.render_workspace.view.lights.source.as_ref().is_some_and(|source| source.method == method && source.settings.ptr_eq(before))
&& before
.upgrade()
.and_then(|settings| {
// A first numerical edit creates the setup from this exact
// controller draft; no unknown source replacement is inferred.
let setup = settings.setups.get(&app.render_workspace.view.name).unwrap_or(draft);
solidcraft_engine::render_lights::inspect(setup).ok()
})
.as_deref()
== Some(rig)
&& rows(app).ok().as_deref() == Some(rig);
if !valid {
loaded(app);
return;
}
let after = std::sync::Arc::downgrade(&app.session.doc.render);
let view = &mut app.render_workspace.view.lights;
if !before.ptr_eq(&after) {
view.numeric_history = Some(NumericHistory { before: before.clone(), after: after.clone() });
}
view.source = Some(Source { settings: after, method });
view.draft = None;
}
pub(crate) fn validate_visibility(app: &SolveApp, params: &Value) -> Result<(), String> {
if let Some(id) = params.get("id").and_then(Value::as_str)
&& !rows(app)?.iter().any(|light| light.id == id)
{
return Err(app.tr("render.light_missing").into());
}
Ok(())
}
pub(crate) fn apply_visibility(app: &mut SolveApp, command: &str, reply: &Value) {
let visibility = &mut app.render_workspace.view.lights.visibility;
let id = reply.get("id").and_then(Value::as_str);
if command == "render.lights.solo" {
visibility.solo = if reply.get("solo").and_then(Value::as_bool) == Some(true) { id.map(str::to_owned) } else { None };
} else if let Some(id) = id {
if reply.get("mute").and_then(Value::as_bool) == Some(true) {
visibility.muted.insert(id.into());
} else {
visibility.muted.remove(id);
}
}
}
pub(super) fn loaded(app: &mut SolveApp) {
let scope_changed = app.render_workspace.view.lights.scope != app.render_workspace.view.name;
if scope_changed {
app.render_workspace.view.lights = View { scope: app.render_workspace.view.name.clone(), ..Default::default() };
}
let source = Source { settings: std::sync::Arc::downgrade(&app.session.doc.render), method: app.render_workspace.view.method };
let view = &mut app.render_workspace.view.lights;
let unknown = scope_changed
|| view.source.as_ref().is_some_and(|previous| {
!(previous.method == source.method && previous.settings.ptr_eq(&source.settings))
&& !view.numeric_history.as_ref().is_some_and(|proof| proof.connects(previous, &source))
});
view.source = Some(source);
if unknown {
// Undo/Redo, checkpoint and arbitrary replacements do not carry an edit
// identity map. Never infer identity from equal kind/count/value lists.
view.visibility = Visibility::default();
view.draft = None;
if matches!(app.render_workspace.view.selection, RenderSelection::Light(_)) {
app.render_workspace.view.selection = RenderSelection::Nothing;
}
}
if let Ok(lights) = rows(app) {
let view = &mut app.render_workspace.view.lights;
view.visibility.muted.retain(|id| lights.iter().any(|light| &light.id == id));
if view.visibility.solo.as_ref().is_some_and(|id| !lights.iter().any(|light| &light.id == id)) {
view.visibility.solo = None;
}
}
}
/// Runs after successful command dispatch, including programmatic control-channel edits.
pub(crate) fn edited(app: &mut SolveApp, command: &str, params: &Value, reply: &Value) {
let Some(name) = reply.get("name").and_then(Value::as_str) else { return };
if name != app.render_workspace.view.name {
return;
}
let before = rows(app).unwrap_or_default();
let remap = reply
.get("id_remap")
.filter(|value| value.as_array().is_some_and(|array| array.len() <= 20))
.and_then(|value| serde_json::from_value::<Vec<LightIdRemap>>(value.clone()).ok())
.unwrap_or_default();
let remap_id = |id: &str| {
remap.iter().find(|entry| entry.before.id == id && before.iter().any(|light| light == &entry.before)).map(|entry| entry.after_id.clone())
};
// One bounded provenance proof keeps the latest verified numerical edit's
// Undo/Redo on the same source. It is not an independent history journal.
// The saved source must match the actual pre-edit draft, not merely its shape.
let history = (|| {
if command != "render.lights.set" || remap.len() != before.len() {
return None;
}
let previous = app.session.undo.last()?;
if previous.label != solidcraft_engine::find_command(command)?.label {
return None;
}
let saved = previous.doc.render.setups.get(name)?;
if solidcraft_engine::render_lights::inspect(saved).ok()? != before {
return None;
}
let cached = app.render_workspace.view.lights.source.as_ref()?;
let source = std::sync::Arc::downgrade(&previous.doc.render);
if !cached.settings.ptr_eq(&source) {
return None;
}
let after = solidcraft_engine::render_lights::inspect(app.session.doc.render.setups.get(name)?).ok()?;
let kind = |light: &Light| (light.geometry.kind(), matches!(light.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. }));
if before.iter().any(|light| {
!remap.iter().any(|entry| {
entry.before == *light && entry.after_id == light.id && after.iter().any(|new| new.id == entry.after_id && kind(new) == kind(light))
})
}) {
return None;
}
Some(NumericHistory { before: source, after: std::sync::Arc::downgrade(&app.session.doc.render) })
})();
if let Some(history) = history {
app.render_workspace.view.lights.numeric_history = Some(history);
}
let previous = &app.render_workspace.view.lights.visibility;
let visibility =
Visibility { solo: previous.solo.as_deref().and_then(remap_id), muted: previous.muted.iter().filter_map(|id| remap_id(id)).collect() };
let selection = match &app.render_workspace.view.selection {
RenderSelection::Light(id) => remap_id(id).map_or(RenderSelection::Nothing, RenderSelection::Light),
other => other.clone(),
};
setups::load(app);
app.render_workspace.view.lights.visibility = visibility;
// Parameter drafts are keyed by old address/revision. Never hand one to a
// different source that now occupies that address after canonicalization.
app.render_workspace.view.lights.draft = None;
loaded(app);
if let Some(aim) = params.get("set").and_then(|set| set.get("aim_at")) {
app.render_workspace.view.lights.aim = serde_json::from_value(aim.clone()).ok();
}
// Add/set/duplicate select the command's actual result. Removing another
// source preserves an unrelated selected source through its explicit map.
app.render_workspace.view.selection = reply.get("id").and_then(Value::as_str).map_or(selection, |id| RenderSelection::Light(id.into()));
}
fn product_centre(app: &SolveApp) -> [f64; 3] {
let bounds = solidcraft_engine::view::bounds(&app.session).unwrap_or(solidcraft_engine::geom::Aabb3::EMPTY);
let point = if bounds.is_empty() { app.cam.target } else { bounds.center() };
[point.x, point.y, point.z]
}
pub(super) fn edit(app: &mut SolveApp, command: &str, id: Option<&str>, mut set: Option<Value>) -> Result<(), String> {
let snapshot = setups::snapshot(app)?;
let mut request = json!({"name":app.render_workspace.view.name,"settings":snapshot,"expected_revision":app.session.revision});
if let Some(id) = id {
request["id"] = json!(id);
}
if let Some(patch) = set.as_mut().and_then(Value::as_object_mut) {
let kind = patch.get("kind").and_then(Value::as_str).or_else(|| id.and_then(|id| id.split_once(':').map(|(kind, _)| kind))).unwrap_or("area");
if kind != "directional"
&& ["kind", "azimuth_deg", "elevation_deg", "distance_mm"].iter().any(|key| patch.contains_key(*key))
&& !patch.contains_key("aim_at")
{
patch.insert("aim_at".into(), json!(app.render_workspace.view.lights.aim.unwrap_or_else(|| product_centre(app))));
}
}
if let Some(set) = set {
request["set"] = set;
}
app.run(command, request).map(|_| ())
}
/// Applied to copies at the request boundary, including engine.execute through SolveApp::run.
/// The draft and saved RenderSetup remain unfiltered, including while saving or undoing.
pub(crate) fn filter_request(app: &SolveApp, mut request: Value) -> Result<Value, String> {
let visibility = &app.render_workspace.view.lights.visibility;
if !visibility.active() {
return Ok(request);
}
if request.is_null() {
request = json!({});
}
if !request.is_object() {
return Err("render request must be an object".into());
}
let mut setup = if let Some(inline) = request.get("settings").filter(|value| !value.is_null()) {
serde_json::from_value::<RenderSetup>(inline.clone()).map_err(|e| e.to_string())?
} else if let Some(name) = request.get("setup").and_then(Value::as_str) {
app.session.doc.render.setups.get(name).cloned().ok_or_else(|| app.tr("render.light_missing").to_string())?
} else {
RenderSetup::default()
};
if setup.job.is_some() {
if let Some(weights) = solidcraft_engine::render_lights::filter(&mut setup, visibility)? {
request["studio_weights"] = json!(weights);
}
if let Some(object) = request.as_object_mut() {
object.remove("setup");
}
request["settings"] = json!(setup);
} else if request.get("progressive").and_then(Value::as_bool) == Some(true) {
let gpu_lighting = request
.get("lighting")
.filter(|value| !value.is_null())
.map(|value| serde_json::from_value(value.clone()).map_err(|e| e.to_string()))
.transpose()?;
let environment = request.get("environment").filter(|value| !value.is_null()).map(|_| SkyEnvironment::Sky {
gradient: Default::default(),
rotation_rad: 0.0,
intensity: 1.0,
});
let mut lighting = RenderSetup {
job: Some(RenderJob::GpuPath {
transparent_background: false,
options: Box::new(GpuJob { lighting: gpu_lighting, environment, ..Default::default() }),
}),
..Default::default()
};
if let Some(weights) = solidcraft_engine::render_lights::filter(&mut lighting, visibility)? {
request["studio_weights"] = json!(weights);
}
if let Some(RenderJob::GpuPath { options, .. }) = lighting.job {
request["lighting"] = json!(options.lighting);
}
} else if request.get("integrator").and_then(Value::as_str) == Some("raytrace") {
let options: solidcraft_engine::render::job::RaytraceOptions =
serde_json::from_value(request.get("raytrace").filter(|value| !value.is_null()).cloned().unwrap_or_else(|| json!({})))
.map_err(|e| e.to_string())?;
let mut lighting = RenderSetup {
job: Some(RenderJob::CpuRaytrace {
transparent_background: false,
options: Box::new(CpuJob {
sun: options.sun.as_deref().copied(),
path: options.path,
progressive: options.progressive,
primary_samples: options.primary_samples,
shadows: options.shadows,
lights: options.lights.clone(),
preset: options.preset,
punctual_lights: options.punctual_lights.clone(),
area_lights: options.area_lights.clone(),
..Default::default()
}),
}),
..Default::default()
};
solidcraft_engine::render_lights::filter(&mut lighting, visibility)?;
if let Some(RenderJob::CpuRaytrace { options: filtered, .. }) = lighting.job {
let mut options = options;
options.sun = filtered.sun.map(Box::new);
options.lights = filtered.lights;
options.preset = filtered.preset;
options.punctual_lights = filtered.punctual_lights;
options.area_lights = filtered.area_lights;
request["raytrace"] = json!(options);
}
} else if let Some(weights) = solidcraft_engine::render_lights::filter(&mut setup, visibility)? {
request["studio_weights"] = json!(weights);
}
Ok(request)
}
/// Unshadowed analytic preview: area sources use their centre and projected area.
/// Final rendering retains the full emitter and transport contracts.
pub(super) fn preview(app: &SolveApp) -> Result<Vec<[f32; 16]>, String> {
let mut output = Vec::new();
for light in rows(app)? {
if !app.render_workspace.view.lights.visibility.visible(&light.id) {
continue;
}
let mut value = [0.0_f32; 16];
let (position, kind) = match light.geometry {
Geometry::Directional { direction, .. } => (direction, 0.0),
Geometry::Point { position_mm, .. } => (position_mm, 1.0),
Geometry::Spot { position_mm, .. } => (position_mm, 2.0),
Geometry::Area { position_mm, .. } => (position_mm, 3.0),
};
for (slot, v) in value.iter_mut().take(3).zip(position) {
*slot = v as f32;
}
if let Some(slot) = value.get_mut(3) {
*slot = kind;
}
for (slot, v) in value.iter_mut().skip(4).take(3).zip(light.colour) {
*slot = (v * light.intensity) as f32;
}
let (axis, inner, outer, scale, minimum) = match light.geometry {
Geometry::Point { reference_distance_mm, minimum_distance_mm, .. } => {
([0.0; 3], 0.0, 0.0, reference_distance_mm.powi(2), minimum_distance_mm)
}
Geometry::Spot {
emitted_axis, inner_half_angle_radians, outer_half_angle_radians, reference_distance_mm, minimum_distance_mm, ..
} => (emitted_axis, inner_half_angle_radians.cos(), outer_half_angle_radians.cos(), reference_distance_mm.powi(2), minimum_distance_mm),
Geometry::Area { edge_u_mm: [ux, uy, uz], edge_v_mm: [vx, vy, vz], .. } => {
let normal = solidcore_record::Vec3::new(ux, uy, uz).cross(solidcore_record::Vec3::new(vx, vy, vz));
let area = normal.len();
let n = solidcraft_engine::render::surface::unit_direction(normal).unwrap_or(-solidcore_record::Vec3::Z);
([n.x, n.y, n.z], 0.0, 0.0, area, 0.001)
}
_ => ([0.0; 3], 0.0, 0.0, 1.0, 0.001),
};
for (slot, v) in value.iter_mut().skip(8).take(3).zip(axis) {
*slot = v as f32;
}
if let Some(slot) = value.get_mut(7) {
*slot = outer as f32;
}
if let Some(slot) = value.get_mut(11) {
*slot = inner as f32;
}
if let Some(slot) = value.get_mut(12) {
*slot = scale as f32;
}
if let Some(slot) = value.get_mut(13) {
*slot = minimum as f32;
}
output.push(value);
}
let view = &app.render_workspace.view;
let ambient = match view.method {
ImageMethod::GpuRaytrace if view.studio.lighting_enabled => view.studio.ambient,
ImageMethod::CpuRaytrace if view.cpu.environment == cpu::Environment::Constant => view.cpu.color.map(|c| c * view.cpu.intensity),
_ => [0.0; 3],
};
if ambient.iter().any(|c| *c > 0.0) {
let mut value = [0.0; 16];
if let Some(slot) = value.get_mut(3) {
*slot = 4.0;
}
for (slot, c) in value.iter_mut().skip(4).take(3).zip(ambient) {
*slot = c as f32;
}
output.push(value);
}
Ok(output)
}
/// The group row and legacy Lighting page share this one editor.
pub(super) fn lighting(app: &mut SolveApp, ui: &mut egui::Ui) {
crate::scenario::publish_target("render:lighting:editor", ui.available_rect_before_wrap());
let method = app.render_workspace.view.method;
let cpu = method == ImageMethod::CpuRaytrace;
let gpu = method == ImageMethod::GpuRaytrace;
let raster = method == ImageMethod::Raster;
let lights = rows(app).unwrap_or_default();
if raster {
note(app, ui, "render.method_limit_raster");
}
ui_kit::scope(ui, |ui| {
let title = app.tr("render.lighting_source_section").to_string();
ui_kit::section(ui, "render:lighting:source", &title, true, |ui| {
let custom = if gpu { app.render_workspace.view.studio.lighting_enabled } else { app.render_workspace.view.raytrace.lights.is_some() };
let mut chosen = usize::from(custom);
let labels = [app.tr("render.lighting_preset").to_string(), app.tr("render.lighting_custom").to_string()];
let reason = app.tr("render.lighting_preset_cpu").to_string();
let disabled = [(!cpu).then_some(reason.as_str()), None];
ui.add_enabled_ui(!raster, |ui| {
let label = app.tr("render.lighting_source").to_string();
ui_kit::row(ui, &label, |ui| {
if ui_kit::segmented(
ui,
&mut chosen,
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
ui_kit::Segments {
compact: true,
disabled: &disabled,
targets: &["render:lighting:preset", "render:lighting:custom"],
..Default::default()
},
) && chosen != usize::from(custom)
{
if chosen == 1 {
let result = (|| {
let mut snapshot = setups::snapshot(app)?;
solidcraft_engine::render_lights::write(&mut snapshot, &lights)?;
save_lighting(app, snapshot)
})();
if let Err(error) = result {
app.set_status(error, true);
}
} else {
review_preset(
app,
app.render_workspace.view.raytrace.preset.unwrap_or(solidcraft_engine::render::job::LightingPreset::Neutral),
);
}
}
});
});
let presets = [
(solidcraft_engine::render::job::LightingPreset::Neutral, "render.cpu_neutral"),
(solidcraft_engine::render::job::LightingPreset::KeyRim, "render.cpu_key_rim"),
(solidcraft_engine::render::job::LightingPreset::WarmCool, "render.cpu_warm_cool"),
];
let selected = app.render_workspace.view.raytrace.preset.unwrap_or(solidcraft_engine::render::job::LightingPreset::Neutral);
let selected_label = presets.iter().find(|(p, _)| *p == selected).map(|(_, key)| *key).unwrap_or("render.cpu_neutral");
ui.add_enabled_ui(cpu && !custom, |ui| {
let label = app.tr("render.lighting_preset_row").to_string();
ui_kit::row(ui, &label, |ui| {
let selected_label = app.tr(selected_label).to_string();
ui_kit::dropdown_menu(ui, "render:lighting:presets", &selected_label, |ui| {
for (preset, key) in presets {
if ui_kit::list_picker(ui, key, app.tr(key), preset == selected).clicked() {
review_preset(app, preset);
ui.close();
}
}
});
});
});
note(app, ui, "render.lighting_custom_help");
if !cpu {
note(app, ui, "render.lighting_preset_cpu");
}
// RenderSetup has no saved rig identity. Do not invent a Rig row.
});
let title = app.tr("render.lighting_shadows_section").to_string();
ui_kit::section(ui, "render:lighting:shadows", &title, true, |ui| {
let mut shadows = if cpu { app.render_workspace.view.raytrace.shadows } else { true };
ui.add_enabled_ui(cpu, |ui| {
if ui_kit::checkbox(ui, app.tr("render.lighting_shadows"), &mut shadows).changed() {
update_cpu(app, |options| options.shadows = shadows);
}
});
if !cpu {
note(app, ui, "render.lighting_shadow_cpu");
}
if cpu {
let enabled = app.render_workspace.view.raytrace.area_lights.as_ref().is_some_and(|l| !l.is_empty());
let mut samples = app.render_workspace.view.raytrace.area_samples.unwrap_or(16);
ui.add_enabled_ui(enabled, |ui| {
let label = app.tr("render.lighting_area_samples").to_string();
ui_kit::row(ui, &label, |ui| {
let response = ui_kit::number_field(ui, &mut samples, 1..=64, 1.0, "");
crate::scenario::publish_target("render:lighting:area-samples", response.rect);
if accepted(&response) {
if [1, 4, 16, 64].contains(&samples) {
update_cpu(app, |options| {
options.area_samples = Some(samples);
});
} else {
app.set_status(app.tr("render.lighting_samples_reason").to_string(), true);
}
}
});
});
note(app, ui, if enabled { "render.lighting_samples_reason" } else { "render.lighting_samples_need_area" });
} else {
note(app, ui, "render.lighting_samples_cpu");
}
});
let title = app.tr("render.lighting_budget").to_string();
ui_kit::section(ui, "render:lighting:budget", &title, true, |ui| {
for (kind, key, limit) in
[("directional", "render.tree_directional", 8), ("area", "render.light_type_area", 4), ("point", "render.light_type_point", 8)]
{
let count = lights
.iter()
.filter(|l| if kind == "point" { matches!(l.geometry.kind(), "point" | "spot") } else { l.geometry.kind() == kind })
.count();
let unsupported = raster;
let label = app.tr(key).to_string();
ui.add_enabled_ui(!unsupported, |ui| {
ui_kit::row(ui, &label, |ui| {
ui.columns(2, |columns| {
for (index, column) in columns.iter_mut().enumerate() {
if index == 0 {
let mut used = count.min(limit) as u32;
column.add_enabled_ui(false, |ui| {
ui_kit::slider(
ui,
&mut used,
0..=limit as u32,
ui_kit::Slider { integer: true, show_value: false, ..Default::default() },
);
});
} else {
let readout = if unsupported {
app.tr("render.lighting_unsupported").to_string()
} else {
crate::i18n::format("render.lighting_used", &[("used", &count.to_string()), ("limit", &limit.to_string())])
};
column.add_enabled_ui(!unsupported, |ui| ui_kit::text(ui, &readout, ui_kit::Text::Inline));
}
}
});
})
});
}
note(app, ui, "render.lighting_budget_help");
add_menu(app, ui);
});
});
}
pub(super) fn add_menu(app: &mut SolveApp, ui: &mut egui::Ui) {
let gpu = app.render_workspace.view.method == ImageMethod::GpuRaytrace;
let raster = app.render_workspace.view.method == ImageMethod::Raster;
let lights = rows(app).unwrap_or_default();
let label = app.tr("render.tree_add_light").to_string();
ui.add_enabled_ui(!raster, |ui| {
ui_kit::dropdown_menu(ui, "render:lighting:add", &label, |ui| {
for (kind, key, cap) in [
("area", "render.light_type_area", 4),
("point", "render.light_type_point", 8),
("spot", "render.light_type_spot", 8),
("directional", "render.tree_directional", 8),
] {
let count = lights
.iter()
.filter(
|l| if matches!(kind, "point" | "spot") { matches!(l.geometry.kind(), "point" | "spot") } else { l.geometry.kind() == kind },
)
.count();
let enabled = count < cap;
let response = ui.add_enabled_ui(enabled, |ui| ui_kit::list_picker(ui, kind, app.tr(key), false)).inner;
crate::scenario::publish_target(&format!("render:lighting:add:{kind}"), response.rect);
if response.on_hover_text(app.tr("render.lighting_budget_help")).clicked() {
dispatch(app, "render.lights.add", None, Some(json!({"kind":kind})));
ui.close();
}
}
{
let compatible = gpu || app.render_workspace.view.raytrace.path.is_some();
let directional = lights.iter().filter(|l| l.geometry.kind() == "directional").count();
let finite = lights.iter().any(|l| matches!(l.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. }));
let response = ui
.add_enabled_ui(compatible && !finite && directional < 8, |ui| {
ui_kit::list_picker(ui, "sun", app.tr("render.light_type_sun"), false)
})
.inner;
crate::scenario::publish_target("render:lighting:add:sun", response.rect);
if response
.backing_on_hover_text(app.tr(if compatible { "render.directional_sun_limit" } else { "render.cpu_celestial_path_required" }))
.clicked()
{
let softness = (0.02 - 0.001) / (std::f64::consts::FRAC_PI_2 - 0.001);
dispatch(app, "render.lights.add", None, Some(json!({"kind":"directional","softness":softness})));
ui.close();
}
}
});
});
}
fn review_preset(app: &mut SolveApp, preset: solidcraft_engine::render::job::LightingPreset) {
match setups::snapshot(app) {
Ok(mut setup) => {
let source = setup.clone();
if let Some(RenderJob::CpuRaytrace { options, .. }) = &mut setup.job {
options.lights = None;
options.preset = Some(preset);
app.render_workspace.view.lights.review = Some(Review {
name: app.render_workspace.view.name.clone(),
source,
setup,
revision: app.session.revision,
document: std::sync::Arc::downgrade(&app.session.doc),
consent: false,
});
}
}
Err(error) => app.set_status(error, true),
}
}
fn save_lighting(app: &mut SolveApp, setup: RenderSetup) -> Result<(), String> {
app.run("render.settings.set", json!({"name":app.render_workspace.view.name,"set":setup}))?;
// Full settings replacement has no source map. Respect loaded()'s proven-
// provenance policy instead of restoring visibility by reused ordinal IDs.
setups::load(app);
Ok(())
}
fn update_cpu(app: &mut SolveApp, update: impl FnOnce(&mut CpuJob)) {
let result = (|| {
let mut setup = setups::snapshot(app)?;
if let Some(RenderJob::CpuRaytrace { options, .. }) = &mut setup.job {
update(options);
}
save_lighting(app, setup)
})();
if let Err(error) = result {
app.set_status(error, true);
}
}
pub(super) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
let Some(mut review) = app.render_workspace.view.lights.review.take() else { return };
if review.revision != app.session.revision
|| review.name != app.render_workspace.view.name
|| setups::snapshot(app).ok().as_ref() != Some(&review.source)
|| !std::sync::Weak::ptr_eq(&review.document, &std::sync::Arc::downgrade(&app.session.doc))
{
app.set_status(app.tr("render.review_stale").to_string(), true);
return;
}
let title = app.tr("render.lighting_review_title").to_string();
let apply = app.tr("render.lighting_apply").to_string();
let cancel = app.tr("render.keep_editing").to_string();
let (closed, action) = ui_kit::Confirm::new(egui::Id::unique("render_lighting_review"), "render_scene", &title)
.actions(&apply, &cancel, None)
.selected(ui_kit::Action::Cancel)
.show(ctx, review.consent, |ui| {
note(app, ui, "render.lighting_review_help");
ui_kit::checkbox(ui, app.tr("render.lighting_consent"), &mut review.consent);
});
match action {
ui_kit::Action::Ok if review.consent => {
if let Err(error) = save_lighting(app, review.setup) {
app.set_status(error, true);
}
}
ui_kit::Action::Cancel => {}
_ if closed => {}
_ => app.render_workspace.view.lights.review = Some(review),
}
}
pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
let lights = match rows(app) {
Ok(lights) => lights,
Err(error) => {
ui_kit::text(ui, &error, ui_kit::Text::Error("render.light_invalid"));
return;
}
};
let Some(light) = lights.iter().find(|light| light.id == id) else {
note(app, ui, "render.light_missing");
return;
};
crate::scenario::publish_target("render:light:editor", ui.available_rect_before_wrap());
let kind = light.geometry.kind();
let gpu = app.render_workspace.view.method == ImageMethod::GpuRaytrace;
let blocked = app.render_workspace.view.method == ImageMethod::Raster;
let finite_sun = matches!(light.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. });
let maximum_ev = if gpu && kind == "area" {
1e6_f64.log2()
} else if finite_sun {
1e8_f64.log2()
} else {
6.0
};
let type_key = match kind {
"area" => "render.light_type_area",
"spot" => "render.light_type_spot",
"point" => "render.light_type_point",
_ => {
if finite_sun {
"render.light_type_sun"
} else {
"render.tree_directional"
}
}
};
let aim = app.render_workspace.view.lights.aim.unwrap_or_else(|| product_centre(app));
let subject_size = subject_size(app);
let (azimuth, elevation, distance) = solidcraft_engine::render_lights::position(light, aim, app.cam.distance);
let (position, direction, u, v, reference, minimum) = match light.geometry {
Geometry::Directional { direction, .. } => ([0.0; 3], direction, [0.0; 3], [0.0; 3], 1.0, 0.001),
Geometry::Area { position_mm, edge_u_mm, edge_v_mm } => (position_mm, [0.0; 3], edge_u_mm, edge_v_mm, 1.0, 0.001),
Geometry::Point { position_mm, reference_distance_mm, minimum_distance_mm }
| Geometry::Spot { position_mm, reference_distance_mm, minimum_distance_mm, .. } => {
(position_mm, [0.0; 3], [0.0; 3], [0.0; 3], reference_distance_mm, minimum_distance_mm)
}
};
let (emitted_axis, inner_angle, outer_angle) = match light.geometry {
Geometry::Spot { emitted_axis, inner_half_angle_radians, outer_half_angle_radians, .. } => {
(emitted_axis, inner_half_angle_radians.to_degrees(), outer_half_angle_radians.to_degrees())
}
_ => ([0.0, 0.0, -1.0], 0.2_f64.to_degrees(), 0.5_f64.to_degrees()),
};
let width = length(u);
let softness = match light.geometry {
Geometry::Directional { angular_radius_rad: Some(radius), .. } => radius.to_degrees(),
Geometry::Area { .. } => (width - 0.0002) / 1000.0,
_ => 0.0,
};
let mut draft =
app.render_workspace.view.lights.draft.take().filter(|draft| draft.id == id && draft.revision == app.session.revision).unwrap_or(Draft {
id: id.into(),
revision: app.session.revision,
ev: bounded(light.intensity.max(2.0_f64.powi(-20)).log2(), -20.0, maximum_ev),
temperature: solidcraft_engine::render_lights::colour_temperature(light.colour),
softness: bounded(softness, 0.0, if kind == "directional" { 90.0 } else { 1.0 }),
azimuth,
elevation,
distance: bounded(distance / subject_size, 0.001 / subject_size, 1e6 / subject_size),
size: width,
height: length(v),
position,
direction,
u,
v,
radiance: light.colour.map(|c| c * light.intensity),
reference,
minimum,
aim,
emitted_axis,
inner_angle,
outer_angle,
});
ui_kit::scope(ui, |ui| {
ui_kit::row(ui, &name(app, light), |ui| {
ui.add_enabled_ui(false, |ui| ui_kit::choice_chip(ui, "render:light:badge", app.tr(type_key), true));
});
if blocked {
note(app, ui, "render.method_limit_raster");
}
ui.add_enabled_ui(!blocked, |ui| {
let labels = [
app.tr("render.light_type_area").to_string(),
app.tr("render.light_type_point").to_string(),
app.tr("render.light_type_spot").to_string(),
app.tr(if finite_sun { "render.light_type_sun" } else { "render.tree_directional" }).to_string(),
];
let kinds = ["area", "point", "spot", "directional"];
let mut selected = kinds.iter().position(|value| *value == kind).unwrap_or(1);
let budget_reason = app.tr("render.lighting_budget_help").to_string();
let areas = lights.iter().filter(|l| l.geometry.kind() == "area").count();
let points = lights.iter().filter(|l| matches!(l.geometry.kind(), "point" | "spot")).count();
let suns = lights.iter().filter(|l| l.geometry.kind() == "directional").count();
let disabled = [
(kind != "area" && areas >= 4).then_some(budget_reason.as_str()),
(kind != "point" && kind != "spot" && points >= 8).then_some(budget_reason.as_str()),
(kind != "point" && kind != "spot" && points >= 8).then_some(budget_reason.as_str()),
(kind != "directional" && suns >= 8).then_some(budget_reason.as_str()),
];
if ui_kit::segmented(
ui,
&mut selected,
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
ui_kit::Segments {
compact: true,
disabled: &disabled,
targets: &["render:light:type:area", "render:light:type:point", "render:light:type:spot", "render:light:type:directional"],
..Default::default()
},
) && let Some(chosen) = kinds.get(selected)
&& *chosen != kind
{
dispatch(app, "render.lights.set", Some(id), Some(json!({"kind":chosen})));
}
slider_field(app, ui, id, "render.light_intensity", "intensity_ev", &mut draft.ev, -20.0..=maximum_ev, |v| format!("{v:+.1} EV"), true);
slider_field(
app,
ui,
id,
"render.lighting_colour",
"temperature_k",
&mut draft.temperature,
1000.0..=40000.0,
|v| format!("{v:.0} K"),
true,
);
note(app, ui, "render.light_temperature_help");
let soft = kind == "area" || finite_sun;
let sun = kind == "directional";
// A sun displays its actual angular radius; areas display the size adapter.
slider_field(
app,
ui,
id,
"render.light_softness",
if sun { "angular_radius_deg" } else { "softness" },
&mut draft.softness,
if finite_sun {
0.001_f64.to_degrees()..=90.0
} else if sun {
0.0..=90.0
} else {
0.0..=1.0
},
if sun { |v| format!("{v:.2}°") } else { |v| format!("{v:.2}") },
soft,
);
if !soft {
note(app, ui, "render.light_hard_shadow");
}
let title = app.tr("render.light_position").to_string();
ui_kit::section(ui, "render:light:position", &title, true, |ui| {
field(app, ui, id, "render.light_azimuth", "azimuth_deg", &mut draft.azimuth, -360.0..=360.0, 1.0, "°", true);
field(app, ui, id, "render.light_elevation", "elevation_deg", &mut draft.elevation, -90.0..=90.0, 1.0, "°", true);
let distance_unit = app.tr("render.lighting_distance_unit").to_string();
field(
app,
ui,
id,
"render.light_distance",
"distance_size",
&mut draft.distance,
0.001 / subject_size..=1e6 / subject_size,
0.1,
&distance_unit,
!sun,
);
if sun {
note(app, ui, "render.lighting_sun_distance");
}
ui.add_enabled_ui(!sun, |ui| {
let label = app.tr("render.light_aim").to_string();
ui_kit::row(ui, &label, |ui| {
let label =
app.tr(if aim == product_centre(app) { "render.light_product_centre" } else { "render.lighting_point" }).to_string();
ui_kit::dropdown_menu(ui, "render:light:aim", &label, |ui| {
let bounds = solidcraft_engine::view::bounds(&app.session).unwrap_or(solidcraft_engine::geom::Aabb3::EMPTY);
let mut targets = vec![
(app.tr("render.light_product_centre").to_string(), product_centre(app)),
(app.tr("render.light_world_origin").to_string(), [0.0; 3]),
];
if !bounds.is_empty() {
for body in &crate::open_meshing::session_world(&app.session).bodies {
let bounds = body.mesh_bounds();
let c = bounds.center();
targets.push((body.name.clone(), [c.x, c.y, c.z]));
}
}
for (label, target) in targets {
if ui_kit::list_picker(ui, &label, &label, aim == target).clicked() {
dispatch(app, "render.lights.set", Some(id), Some(json!({"aim_at":target})));
ui.close();
}
}
});
});
vector_field(app, ui, id, "render.lighting_aim_point", "aim_at", &mut draft.aim, -1e9..=1e9, " mm");
});
let response = ui_kit::button(ui, app.tr("render.light_place_highlight"), ui_kit::Button::Enabled(false));
crate::scenario::publish_target("render:light:place-highlight", response.rect);
response.backing_on_hover_text(app.tr("render.light_place_pending"));
note(app, ui, "render.light_place_pending");
if sun {
note(app, ui, "render.lighting_direction_help");
vector_field(app, ui, id, "render.lighting_direction", "direction", &mut draft.direction, -1e6..=1e6, "");
} else {
vector_field(
app,
ui,
id,
"render.lighting_world_position",
"position_mm",
&mut draft.position,
if gpu || matches!(kind, "point" | "spot") { -1e9..=1e9 } else { -1e12..=1e12 },
" mm",
);
}
});
if kind == "area" {
let title = app.tr("render.lighting_shape").to_string();
ui_kit::section(ui, "render:light:shape", &title, true, |ui| {
field(
app,
ui,
id,
"render.lighting_width",
"width_mm",
&mut draft.size,
if gpu { 0.0002..=2e6 } else { 0.000002..=1e6 },
1.0,
" mm",
true,
);
field(
app,
ui,
id,
"render.lighting_height",
"height_mm",
&mut draft.height,
if gpu { 0.0002..=2e6 } else { 0.000002..=1e6 },
1.0,
" mm",
true,
);
vector_field(app, ui, id, "render.lighting_radiance", "radiance", &mut draft.radiance, 0.0..=if gpu { 1e6 } else { 64.0 }, "");
vector_field(app, ui, id, "render.lighting_edge_u", "edge_u_mm", &mut draft.u, if gpu { -2e6..=2e6 } else { -1e6..=1e6 }, " mm");
vector_field(app, ui, id, "render.lighting_edge_v", "edge_v_mm", &mut draft.v, if gpu { -2e6..=2e6 } else { -1e6..=1e6 }, " mm");
});
}
if kind == "spot" {
let title = app.tr("render.spot_cone").to_string();
ui_kit::section(ui, "render:light:cone", &title, true, |ui| {
vector_field(app, ui, id, "render.spot_axis", "emitted_axis", &mut draft.emitted_axis, -1e9..=1e9, "");
field(app, ui, id, "render.spot_inner", "inner_half_angle_radians", &mut draft.inner_angle, 0.0..=90.0, 0.1, "°", true);
field(app, ui, id, "render.spot_outer", "outer_half_angle_radians", &mut draft.outer_angle, 0.0..=90.0, 0.1, "°", true);
note(app, ui, if gpu { "render.spot_gpu_help" } else { "render.spot_help" });
});
}
if matches!(kind, "point" | "spot") {
let title = app.tr("render.lighting_falloff").to_string();
ui_kit::section(ui, "render:light:falloff", &title, true, |ui| {
field(
app,
ui,
id,
"render.lighting_reference",
"reference_distance_mm",
&mut draft.reference,
draft.minimum..=1e6,
1.0,
" mm",
true,
);
field(
app,
ui,
id,
"render.lighting_minimum",
"minimum_distance_mm",
&mut draft.minimum,
0.001..=draft.reference,
1.0,
" mm",
true,
);
note(app, ui, "render.lighting_falloff_help");
});
}
});
app.render_workspace.view.lights.draft = Some(draft);
let title = app.tr("render.light_behaviour").to_string();
ui_kit::section(ui, "render:light:behaviour", &title, true, |ui| {
let mut solo = app.render_workspace.view.lights.visibility.solo.as_deref() == Some(id);
if ui_kit::checkbox(ui, app.tr("render.lighting_solo"), &mut solo).changed() {
let _ = app.run("render.lights.solo", json!({"id":id,"solo":solo}));
}
let mut muted = app.render_workspace.view.lights.visibility.muted.contains(id);
if ui_kit::checkbox(ui, app.tr("render.lighting_mute"), &mut muted).changed() {
let _ = app.run("render.lights.mute", json!({"id":id,"mute":muted}));
}
ui.horizontal(|ui| {
let cap = if kind == "area" { 4 } else { 8 };
let count = lights
.iter()
.filter(
|l| if matches!(kind, "point" | "spot") { matches!(l.geometry.kind(), "point" | "spot") } else { l.geometry.kind() == kind },
)
.count();
if ui_kit::button(ui, app.tr("render.light_duplicate"), ui_kit::Button::Enabled(!blocked && !finite_sun && count < cap))
.backing_on_hover_text(app.tr(if finite_sun { "render.directional_sun_limit" } else { "render.lighting_budget_help" }))
.clicked()
{
dispatch(app, "render.lights.duplicate", Some(id), None);
}
if ui_kit::button(ui, app.tr("render.light_delete"), ui_kit::Button::Enabled(!blocked)).clicked() {
dispatch(app, "render.lights.remove", Some(id), None);
}
});
note(app, ui, "render.light_view_only");
});
});
}
fn bounded(value: f64, low: f64, high: f64) -> f64 {
if value.is_finite() { value.clamp(low, high) } else { low }
}
fn length([x, y, z]: [f64; 3]) -> f64 {
x.hypot(y).hypot(z)
}
fn subject_size(app: &SolveApp) -> f64 {
bounded(solidcraft_engine::view::bounds(&app.session).unwrap_or(solidcraft_engine::geom::Aabb3::EMPTY).diagonal(), 1.0, 1e6)
}
fn note(app: &SolveApp, ui: &mut egui::Ui, key: &'static str) {
ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
}
#[allow(clippy::too_many_arguments)]
fn slider_field(
app: &mut SolveApp,
ui: &mut egui::Ui,
id: &str,
label: &str,
key: &str,
value: &mut f64,
range: std::ops::RangeInclusive<f64>,
format: fn(f64) -> String,
enabled: bool,
) {
let label = app.tr(label).to_string();
ui.add_enabled_ui(enabled, |ui| {
ui_kit::row(ui, &label, |ui| {
let response = ui_kit::slider(ui, value, range.clone(), ui_kit::Slider { format, ..Default::default() });
crate::scenario::publish_target(&format!("render:light:{key}"), response.rect);
if accepted(&response) && value.is_finite() && range.contains(value) {
let patch = if key == "angular_radius_deg" {
json!({"softness":(value.to_radians() - 0.001) / (std::f64::consts::FRAC_PI_2 - 0.001)})
} else {
json!({(key):*value})
};
dispatch(app, "render.lights.set", Some(id), Some(patch));
}
});
});
}
#[allow(clippy::too_many_arguments)]
fn vector_field(
app: &mut SolveApp,
ui: &mut egui::Ui,
id: &str,
label: &str,
key: &str,
value: &mut [f64; 3],
range: std::ops::RangeInclusive<f64>,
suffix: &str,
) {
let label = app.tr(label).to_string();
// Each coordinate needs the full control column: three content-sized
// DragValues can extend beyond a narrow inspector as their text grows.
// Separate axis rows retain the standard parser, focus and accessible label.
let mut changed = false;
for ((index, component), axis) in value.iter_mut().enumerate().zip(["X", "Y", "Z"]) {
ui_kit::row(ui, &format!("{label} {axis}"), |ui| {
let response = ui_kit::number_field(ui, component, range.clone(), 0.1, suffix);
crate::scenario::publish_target(&format!("render:light:{key}:{index}"), response.rect);
changed |= accepted(&response);
});
}
if changed && value.iter().all(|v| v.is_finite() && range.contains(v)) {
dispatch(app, "render.lights.set", Some(id), Some(json!({(key):*value})));
}
}
fn accepted(response: &egui::Response) -> bool {
response.drag_stopped() || (response.changed() && (response.has_focus() || response.lost_focus()))
}
fn dispatch(app: &mut SolveApp, command: &str, id: Option<&str>, set: Option<Value>) {
if let Err(error) = edit(app, command, id, set) {
app.set_status(error, true);
}
}
#[allow(clippy::too_many_arguments)]
fn field(
app: &mut SolveApp,
ui: &mut egui::Ui,
id: &str,
label: &str,
key: &str,
value: &mut f64,
range: std::ops::RangeInclusive<f64>,
speed: f64,
suffix: &str,
enabled: bool,
) {
let label = app.tr(label).to_string();
ui.add_enabled_ui(enabled, |ui| {
ui_kit::row(ui, &label, |ui| {
let response = ui_kit::number_field(ui, value, range.clone(), speed, suffix);
crate::scenario::publish_target(&format!("render:light:{key}"), response.rect);
if accepted(&response) && value.is_finite() && range.contains(value) {
let patch = if key == "distance_size" {
json!({"distance_mm":*value * subject_size(app)})
} else if matches!(key, "inner_half_angle_radians" | "outer_half_angle_radians") {
json!({(key):value.to_radians()})
} else {
json!({(key):*value})
};
dispatch(app, "render.lights.set", Some(id), Some(patch));
}
})
});
}
#[cfg(test)]
pub(super) fn editor_draft(app: &SolveApp) -> Option<(String, u64, f64, f64)> {
app.render_workspace.view.lights.draft.as_ref().map(|draft| (draft.id.clone(), draft.revision, draft.ev, draft.softness))
}