SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Standalone Shot editor and transient frame composition. Commands own every edit.
use super::{RenderSelection, Stage, inspector};
use crate::{SolveApp, theme::Tokens, ui_kit};
use egui::{Rect, pos2, vec2};
use serde_json::{Value, json};
use solidcraft_engine::doc::render_settings::{RenderSettings, RenderSetup};
#[derive(Clone, Debug, Default)]
pub(crate) struct Frame {
aspect: Option<String>,
pub(super) guides: ui_kit::FrameGuides,
name: Option<(String, String)>,
exposure: Option<(String, f64, f64)>,
}
pub(crate) fn apply_frame(app: &mut SolveApp, request: &Value) {
let frame = &mut app.render_workspace.view.frame;
if let Some(aspect) = request.get("aspect").and_then(Value::as_str) {
frame.aspect = Some(aspect.into());
}
for (key, value) in
[("thirds", &mut frame.guides.thirds), ("safe_area", &mut frame.guides.safe_area), ("centre_mark", &mut frame.guides.centre_mark)]
{
if let Some(request) = request.get(key).and_then(Value::as_bool) {
*value = request;
}
}
}
pub(super) fn selected(app: &SolveApp) -> Option<&str> {
match &app.render_workspace.view.selection {
RenderSelection::Shot(name) if app.session.doc.render.setups.contains_key(name) => Some(name),
_ => None,
}
}
const ASPECTS: [(&str, u32, u32, &str); 6] = [
("16:9", 1920, 1080, "render.frame_wide"),
("3:2", 1620, 1080, "render.frame_photo"),
("1:1", 1080, 1080, "render.frame_square"),
("4:5", 864, 1080, "render.frame_portrait"),
("9:16", 1080, 1920, "render.frame_tall"),
("custom", 0, 0, "render.frame_custom"),
];
fn target(app: &SolveApp) -> String {
selected(app).unwrap_or(&app.render_workspace.view.name).to_owned()
}
fn setup(app: &SolveApp, name: &str) -> RenderSetup {
app.session.doc.render.setups.get(name).cloned().unwrap_or_else(|| app.render_workspace.view.draft.clone())
}
pub(super) fn aspect_label(app: &SolveApp, setup: &RenderSetup) -> String {
ASPECTS.get(aspect_index(app, setup)).map_or_else(
|| app.tr("render.frame_custom").to_string(),
|(key, ..)| if *key == "custom" { app.tr("render.frame_custom").to_string() } else { (*key).into() },
)
}
fn aspect_index(app: &SolveApp, setup: &RenderSetup) -> usize {
if let Some(aspect) = &app.render_workspace.view.frame.aspect
&& let Some(index) = ASPECTS.iter().position(|(key, ..)| *key == aspect)
{
return index;
}
ASPECTS.iter().position(|(_, w, h, _)| *w > 0 && u64::from(setup.width) * u64::from(*h) == u64::from(setup.height) * u64::from(*w)).unwrap_or(5)
}
/// Patch only the requested saved fields; unrelated live drafts and the live camera survive.
pub(super) fn edit_settings(app: &mut SolveApp, name: &str, patch: Value) -> Result<(), String> {
app.run("render.settings.set", json!({"name":name,"set":patch}))?;
if name == app.render_workspace.view.name {
let saved = setup(app, name);
let view = &mut app.render_workspace.view;
for draft in std::iter::once(&mut view.draft).chain(view.clean_setup.iter_mut()) {
if patch.get("width").is_some() {
draft.width = saved.width;
}
if patch.get("height").is_some() {
draft.height = saved.height;
}
if patch.get("exposure_ev").is_some() {
draft.exposure_ev = saved.exposure_ev;
}
if patch.get("job").is_some() {
draft.job = saved.job.clone();
}
if patch.get("camera").is_some() {
draft.camera = saved.camera;
}
}
app.render_workspace.revision = app.session.revision;
}
Ok(())
}
pub(super) fn choose_aspect(app: &mut SolveApp, name: &str, index: usize) -> Result<(), String> {
let Some((aspect, width, height, _)) = ASPECTS.get(index) else { return Err(app.tr("render.frame_invalid_aspect").into()) };
if *width > 0 {
edit_settings(app, name, json!({"width":width,"height":height}))?;
}
app.run("view.render_frame", json!({"aspect":aspect}))?;
Ok(())
}
fn result(app: &mut SolveApp, action: Result<(), String>) {
if let Err(error) = action {
app.set_status(error, true);
}
}
fn guides(app: &mut SolveApp, ui: &mut egui::Ui, editor: bool) {
let current = app.render_workspace.view.frame.guides;
for (key, label, mut checked) in [
("thirds", if editor { "render.frame_rule_thirds" } else { "render.frame_thirds" }, current.thirds),
("safe_area", "render.frame_safe_area", current.safe_area),
("centre_mark", "render.frame_centre_mark", current.centre_mark),
] {
let response = ui_kit::checkbox(ui, app.tr(label), &mut checked);
crate::scenario::publish_target(&format!("render:{}:{key}", if editor { "shot" } else { "frame" }), response.rect);
if response.changed() {
let _ = app.run("view.render_frame", json!({key:checked}));
}
}
}
pub(super) fn presets(app: &mut SolveApp, ui: &mut egui::Ui) {
let name = target(app);
let current = setup(app, &name);
let selected = aspect_index(app, ¤t);
let title = app.tr("render.frame_aspect").to_string();
ui_kit::section(ui, "render_frame_aspects", &title, true, |ui| {
let ids: Vec<_> = ASPECTS.iter().map(|(key, ..)| format!("render:frame:aspect:{key}")).collect();
let tiles: Vec<_> = ASPECTS
.iter()
.enumerate()
.map(|(index, (key, w, h, _))| ui_kit::AspectTile {
id: ids.get(index).map(String::as_str).unwrap_or_default(),
label: if *key == "custom" { app.tr("render.frame_custom") } else { key },
aspect: if *h == 0 { 1.5 } else { f64::from(*w) / f64::from(*h) },
selected: index == selected,
})
.collect();
if let Some(index) = ui_kit::aspect_grid(ui, &tiles) {
let action = choose_aspect(app, &name, index);
result(app, action);
}
});
let title = app.tr("render.frame_guides").to_string();
ui_kit::section(ui, "render_frame_guides", &title, true, |ui| guides(app, ui, false));
}
pub(super) fn rename(app: &mut SolveApp, name: &str, new_name: &str) -> Result<(), String> {
app.run("render.shot.rename", json!({"name":name,"new_name":new_name,"expected_revision":app.session.revision}))?;
if app.render_workspace.view.name == name {
app.render_workspace.view.name = new_name.into();
}
app.run("view.render_select", json!({"kind":"shot","id":new_name}))?;
Ok(())
}
pub(super) fn duplicate(app: &mut SolveApp, name: &str) -> Result<(), String> {
for number in 1..=32 {
let mut prefix = name.to_string();
let mut destination = crate::i18n::format("render.frame_copy_name", &[("name", &prefix), ("number", &number.to_string())]);
while destination.len() > solidcraft_engine::doc::render_settings::MAX_SETUP_NAME_BYTES && prefix.pop().is_some() {
destination = crate::i18n::format("render.frame_copy_name", &[("name", &prefix), ("number", &number.to_string())]);
}
if !app.session.doc.render.setups.contains_key(&destination) {
app.run("render.shot.duplicate", json!({"name":name,"new_name":destination,"expected_revision":app.session.revision}))?;
return Ok(());
}
}
Err(app.tr("render.frame_copy_limit").into())
}
pub(super) fn revert(app: &mut SolveApp, name: &str) -> Result<(), String> {
inspector::restore_saved_camera(app, name)
}
/// E7: saved camera, lens, exposure and frame in approved order.
pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str) {
let Some(saved) = app.session.doc.render.setups.get(shot).cloned() else { return };
if app.render_workspace.view.frame.name.as_ref().is_none_or(|(name, _)| name != shot) {
app.render_workspace.view.frame.name = Some((shot.into(), shot.into()));
}
let mut name = app.render_workspace.view.frame.name.as_ref().map(|(_, text)| text.clone()).unwrap_or_else(|| shot.into());
let invalid = RenderSettings::validate_name(&name).is_err();
let response = ui_kit::row(ui, app.tr("render.frame_name"), |ui| {
ui_kit::bounded_cell_editor(ui, ui.scope_id().with(("shot_name", shot)), &mut name, "", invalid, 128)
});
crate::scenario::publish_target("render:shot:name", response.rect);
let commit = response.lost_focus() || (response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
app.render_workspace.view.frame.name = Some((shot.into(), name.clone()));
if commit && name != shot {
let action = rename(app, shot, name.trim());
result(app, action);
return;
}
let changed = super::shots::camera_modified(app, shot);
if changed {
ui_kit::banner(ui, ui_kit::AssistantTone::Warning, |ui| {
ui_kit::text(ui, app.tr("render.shots_camera_changed"), ui_kit::Text::Note("render.shots_camera_changed"));
});
}
ui.horizontal_wrapped(|ui| {
let update = ui.add_enabled_ui(changed, |ui| ui_kit::primary_button(ui, app.tr("render.shots_update"))).inner;
crate::scenario::publish_target("render:shot:update", update.rect);
if update.clicked() {
let action = edit_settings(app, shot, json!({"camera":app.cam}));
result(app, action);
}
let response = ui_kit::button(ui, app.tr("render.shots_revert"), ui_kit::Button::Enabled(changed));
crate::scenario::publish_target("render:shot:revert", response.rect);
if response.clicked() {
let action = revert(app, shot);
result(app, action);
}
for (id, icon, label, danger) in [("duplicate", "copy", "render.frame_duplicate", false), ("remove", "delete", "render.shot_remove", true)] {
let response = ui_kit::icon_action(ui, app.tr(label), icon, true, danger);
crate::scenario::publish_target(&format!("render:shot:{id}"), response.rect);
if response.clicked() {
if danger {
inspector::shot_row_action(app, shot.into(), "render.shot.remove");
} else {
let action = duplicate(app, shot);
result(app, action);
}
}
}
});
let title = app.tr("render.page_camera").to_string();
ui_kit::section(ui, "render_shot_camera", &title, true, |ui| camera(app, ui, shot));
let title = app.tr("render.shot_lens").to_string();
ui_kit::section(ui, "render_shot_lens", &title, true, |ui| lens(app, ui, shot, &saved));
let title = app.tr("render.shot_exposure_section").to_string();
ui_kit::section(ui, "render_shot_exposure", &title, true, |ui| exposure(app, ui, shot, &saved));
let title = app.tr("render.stage_frame").to_string();
ui_kit::section(ui, "render_shot_frame", &title, true, |ui| {
let index = aspect_index(app, &saved);
let mut chosen = None;
let labels: Vec<_> = ASPECTS.iter().map(|(_, _, _, key)| app.tr(key).to_string()).collect();
ui_kit::row(ui, app.tr("render.frame_aspect"), |ui| {
let response = ui_kit::dropdown_menu(ui, "render_shot_aspect", labels.get(index).map(String::as_str).unwrap_or_default(), |ui| {
for (choice, label) in labels.iter().enumerate() {
if ui_kit::list_picker(ui, &format!("render:shot:aspect:{choice}"), label, choice == index).clicked() {
chosen = Some(choice);
ui.close();
}
}
});
crate::scenario::publish_target("render:shot:aspect", response.rect);
});
if let Some(index) = chosen {
let action = choose_aspect(app, shot, index);
result(app, action);
}
guides(app, ui, true);
ui.horizontal_wrapped(|ui| {
ui_kit::text(ui, app.tr("render.shot_size"), ui_kit::Text::Inline);
ui_kit::text(ui, &format!("{} × {}", saved.width, saved.height), ui_kit::Text::Inline);
let response = ui_kit::button(ui, app.tr("render.shot_edit_output"), ui_kit::Button::Ghost);
crate::scenario::publish_target("render:shot:output", response.rect);
if response.clicked() {
let _ = app.run("view.render_select", json!({"kind":"output"}));
}
});
});
}
/// Controls save immediately; navigation alone keeps Update/Revert.
pub(super) fn set_camera(app: &mut SolveApp, shot: &str, camera: solidcraft_engine::render::Camera) -> Result<(), String> {
if !camera.is_valid() {
return Err(app.tr("render.shot_invalid_camera").into());
}
edit_settings(app, shot, json!({"camera":camera}))?;
inspector::apply_camera_draft(app, camera)
}
fn camera(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str) {
let mut camera = app.cam;
let mut projection = usize::from(camera.fov == 0.0);
// This short label can use the kit's base column, leaving both projection names visible.
if ui_kit::settings_form(ui, Tokens::get().form_label_width, |ui| {
ui_kit::row(ui, app.tr("render.frame_projection"), |ui| {
ui_kit::segmented(
ui,
&mut projection,
&[app.tr("render.perspective"), app.tr("render.stage_orthographic")],
ui_kit::Segments { compact: true, proportional: true, workspace_accent: true, ..Default::default() },
)
})
}) {
camera.fov = if projection == 0 { 35f64.to_radians() } else { 0.0 };
}
let mut fov = if projection == 0 { camera.fov.to_degrees() } else { 35.0 };
ui.add_enabled_ui(projection == 0, |ui| {
let response = ui_kit::row(ui, app.tr("render.frame_fov"), |ui| {
ui_kit::slider(ui, &mut fov, 1.0..=150.0, ui_kit::Slider { format: |v| format!("{v:.0}°"), ..Default::default() })
});
if projection == 0 && response.changed() && (response.is_pointer_button_down_on() || response.has_focus()) {
camera.fov = fov.to_radians();
}
});
let bounds = crate::viewport::model_bounds(app);
let diagonal = bounds.diagonal();
let size = if bounds.is_empty() || !diagonal.is_finite() { 1.0 } else { diagonal.max(0.000001) };
let mut distance = camera.distance / size;
let suffix = app.tr("render.frame_distance_unit").to_owned();
let response = ui_kit::row(ui, app.tr("render.shot_distance"), |ui| {
ui_kit::number_field(ui, &mut distance, (0.000001 / size)..=(1e9 / size), 0.01, &suffix)
});
crate::scenario::publish_target("render:shot:distance", response.rect);
if response.changed() {
camera.distance = distance * size;
}
let mut target = [camera.target.x, camera.target.y, camera.target.z];
ui_kit::row(ui, app.tr("render.shot_target"), |ui| {
ui_kit::number_fields(ui, &mut target, -1e9..=1e9, 0.1, "");
});
camera.target = solidcore_record::Vec3::new(target[0], target[1], target[2]);
for (key, value) in [("camera.shot_yaw", &mut camera.yaw), ("camera.shot_pitch", &mut camera.pitch), ("camera.shot_roll", &mut camera.roll)] {
let mut degrees = value.to_degrees();
if ui_kit::row(ui, app.tr(key), |ui| ui_kit::number_field(ui, &mut degrees, (-1e6f64).to_degrees()..=1e6f64.to_degrees(), 0.5, "°")).changed()
{
*value = degrees.to_radians();
}
}
if camera != app.cam {
let action = set_camera(app, shot, camera);
result(app, action);
}
if projection != 0 {
ui_kit::text(ui, app.tr("render.shot_fov_reason"), ui_kit::Text::Note("render.shot_fov_reason"));
}
ui.horizontal_wrapped(|ui| {
if ui_kit::button(ui, app.tr("render.shot_frame_subject"), ui_kit::Button::Normal).clicked() {
let action = inspector::fit_subject(app).and_then(|()| set_camera(app, shot, app.cam));
result(app, action);
}
let enabled = crate::viewport::selection_bounds(app).is_some();
let response = ui_kit::button(ui, app.tr("render.shot_look_selection"), ui_kit::Button::Enabled(enabled));
crate::scenario::publish_target("render:shot:look-selection", response.rect);
if response.clicked() {
let action = look_at_selection(app, shot);
result(app, action);
}
});
if crate::viewport::selection_bounds(app).is_none() {
ui_kit::text(ui, app.tr("render.shot_selection_reason"), ui_kit::Text::Note("render.shot_selection_reason"));
}
}
pub(super) fn look_at_selection(app: &mut SolveApp, shot: &str) -> Result<(), String> {
let bounds = crate::viewport::selection_bounds(app).ok_or_else(|| app.tr("render.shot_selection_reason").to_string())?;
set_camera(app, shot, solidcraft_engine::render::Camera { target: bounds.center(), ..app.cam })
}
/// Change only saved lens intent. Camera updates keep their explicit Update shot action.
pub(super) fn set_lens(app: &mut SolveApp, shot: &str, lens: Option<solidcraft_engine::render::job::ThinLens>) -> Result<(), String> {
use solidcraft_engine::doc::render_settings::RenderJob;
let saved = app.session.doc.render.setups.get(shot).ok_or_else(|| app.tr("render.ribbon_no_saved_camera").to_string())?;
let active = app.render_workspace.view.name == shot;
let establishing_job = active && saved.job.is_none();
let mut candidate = if active {
super::setups::snapshot_with_lens(app, lens)?
} else {
let mut candidate = saved.clone();
match &mut candidate.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()),
}
candidate
};
// Numerical lens intent uses the visible method, but never adopts navigation.
candidate.camera = saved.camera;
candidate.validate().map_err(|error| error.to_string())?;
let patch = if establishing_job {
let mut patch = serde_json::to_value(&candidate).map_err(|error| error.to_string())?;
if let Some(fields) = patch.as_object_mut() {
fields.remove("camera");
}
patch
} else {
// Validate the visible draft above, but save only lens intent on the saved job.
// Independent method and sampling edits keep their own dirty state.
let mut job = saved.job.clone();
match &mut 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()),
}
json!({"job":job})
};
edit_settings(app, shot, patch)?;
if active {
app.render_workspace.view.studio.lens_enabled = lens.is_some();
if let Some(value) = lens {
app.render_workspace.view.studio.lens = value;
}
app.render_workspace.view.raytrace.lens = lens;
if establishing_job {
let view = &mut app.render_workspace.view;
let camera = view.clean_setup.as_ref().map_or(app.cam, |clean| clean.camera);
view.clean_setup = Some(RenderSetup { camera, ..candidate });
view.clean_persisted = true;
view.clean_name = shot.into();
}
super::setups::refresh_dirty(app);
}
Ok(())
}
fn lens(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str, saved: &RenderSetup) {
use solidcraft_engine::doc::render_settings::RenderJob;
// A fresh native CPU default is transient until the first numerical edit.
// Read its visible method here; opening Frame must not write that job to Studio.
let current = if app.render_workspace.view.name == shot {
super::setups::snapshot(app).or_else(|_| super::setups::draft(app)).unwrap_or_else(|_| saved.clone())
} else {
saved.clone()
};
let (supported, sampling, lens) = match ¤t.job {
Some(RenderJob::CpuRaytrace { options, .. }) => (true, options.progressive.is_some(), options.lens),
Some(RenderJob::GpuPath { options, .. }) => (true, true, options.lens),
_ => (false, false, None),
};
let mut on = lens.is_some();
let mut value = lens.unwrap_or(app.render_workspace.view.studio.lens);
let perspective = saved.camera.fov > 0.0 && app.cam.fov > 0.0;
let compatible = supported && sampling && perspective;
// Removing an authored lens remains possible after navigating to orthographic.
let mut changed = false;
ui.add_enabled_ui(supported && (on || compatible), |ui| {
let response = ui_kit::checkbox(ui, app.tr("render.shot_dof"), &mut on);
crate::scenario::publish_target("render:shot:dof", response.rect);
changed |= response.changed();
});
ui.add_enabled_ui(on && compatible, |ui| {
changed |=
ui_kit::row(ui, app.tr("render.shot_aperture"), |ui| ui_kit::number_field(ui, &mut value.aperture_radius_mm, 0.0..=1e7, 0.1, " mm"))
.changed();
changed |= ui_kit::row(ui, app.tr("render.shot_focus_distance"), |ui| {
ui_kit::number_field(ui, &mut value.focus_distance_mm, 1e-6..=1e9, 1.0, " mm")
})
.changed();
});
let reason = if !supported {
Some("render.shot_lens_raytrace_reason")
} else if !sampling {
Some("render.shot_lens_cpu_progressive_reason")
} else if !perspective {
Some("render.shot_lens_perspective_reason")
} else if !on {
Some("render.shot_lens_enable_reason")
} else {
None
};
if let Some(key) = reason {
ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
}
if changed {
let action = set_lens(app, shot, on.then_some(value));
result(app, action);
}
}
fn exposure(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str, saved: &RenderSetup) {
let limit = if matches!(saved.job, Some(solidcraft_engine::doc::render_settings::RenderJob::CpuRaytrace { .. })) { 16.0 } else { 32.0 };
let enabled = !matches!(saved.job, None | Some(solidcraft_engine::doc::render_settings::RenderJob::Raster { .. }));
if !enabled {
ui_kit::text(ui, app.tr("render.shot_exposure_reason"), ui_kit::Text::Note("render.shot_exposure_reason"));
}
ui.add_enabled_ui(enabled, |ui| {
if app.render_workspace.view.frame.exposure.as_ref().is_none_or(|(name, observed, _)| name != shot || *observed != saved.exposure_ev) {
app.render_workspace.view.frame.exposure = Some((shot.into(), saved.exposure_ev, saved.exposure_ev));
}
let mut exposure = app.render_workspace.view.frame.exposure.as_ref().map_or(saved.exposure_ev, |(_, _, value)| *value);
let response = ui_kit::row(ui, app.tr("render.frame_exposure"), |ui| {
ui_kit::slider(ui, &mut exposure, -limit..=limit, ui_kit::Slider { format: |v| format!("{v:+.1} EV"), ..Default::default() })
});
crate::scenario::publish_target("render:shot:exposure", response.rect);
app.render_workspace.view.frame.exposure = Some((shot.into(), saved.exposure_ev, exposure));
if exposure != saved.exposure_ev && !ui.input(|i| i.pointer.primary_down()) {
let action = edit_settings(app, shot, json!({"exposure_ev":exposure}));
if action.is_err() {
app.render_workspace.view.frame.exposure = None;
}
result(app, action);
}
});
}
/// Largest centred frame at an aspect. Reject invalid or unrepresentable geometry before arithmetic.
pub(super) fn frame_rect(aspect: f64, viewport: Rect) -> Option<Rect> {
if !aspect.is_finite() || !(1e-6..=1e6).contains(&aspect) || !viewport.is_finite() || !viewport.is_positive() || viewport.size().max_elem() > 1e7
{
return None;
}
let width = f64::from(viewport.width()).min(f64::from(viewport.height()) * aspect);
let height = width / aspect;
let frame = Rect::from_center_size(viewport.center(), vec2(width as f32, height as f32));
(frame.is_finite() && frame.is_positive()).then_some(frame)
}
pub(crate) fn overlay_visible(app: &SolveApp) -> bool {
!app.render_workspace.view.result && (app.render_workspace.view.stage == Stage::Frame || selected(app).is_some())
}
/// Actual output-camera frame, independent of inspector focus and transient guides.
/// Retained result/compare views use their captured image dimensions separately.
pub(crate) fn render_rect(app: &SolveApp, viewport: Rect) -> Rect {
if app.preferences.render_legacy_image_defaults {
return preview_rect(app, viewport).unwrap_or(viewport);
}
let free = crate::shell::workspace_content(app, crate::render_ui::canvas(app, viewport));
// With no surrounding chrome, an equal-aspect image uses the same full
// rectangle as Design. The normal workspace still keeps its card margin.
let frame_area = if free == viewport { free } else { free.shrink(Tokens::get().space_8) };
frame_rect(super::image_aspect(&app.render_workspace.view.draft), frame_area).unwrap_or(free)
}
/// Contextual composition guides may preview a transient/selected-shot aspect.
/// Their visibility/aspect must never choose the nonlegacy rendered projection.
pub(crate) fn preview_rect(app: &SolveApp, viewport: Rect) -> Option<Rect> {
if !overlay_visible(app) {
return None;
}
let saved = setup(app, &target(app));
let index = aspect_index(app, &saved);
let aspect = ASPECTS
.get(index)
.filter(|(_, _, height, _)| *height > 0)
.map_or(f64::from(saved.width) / f64::from(saved.height), |(_, width, height, _)| f64::from(*width) / f64::from(*height));
let free = crate::shell::workspace_content(app, crate::render_ui::canvas(app, viewport));
frame_rect(aspect, free.shrink(Tokens::get().space_8))
}
pub(crate) fn overlay(app: &mut SolveApp, ui: &mut egui::Ui, viewport: Rect) {
if !overlay_visible(app) {
return;
}
let t = Tokens::get();
let saved = setup(app, &target(app));
let Some(frame) = preview_rect(app, viewport) else { return };
ui_kit::frame_guides(ui, viewport, frame, app.render_workspace.view.frame.guides);
crate::scenario::publish_rect("render:frame:overlay", frame);
let index = aspect_index(app, &saved);
let aspect = ASPECTS.get(index).map(|(key, ..)| *key).unwrap_or("custom");
let aspect = if aspect == "custom" { app.tr("render.frame_custom") } else { aspect };
let label = format!("{aspect} · {} × {}", saved.width, saved.height);
ui_kit::Container::navigation_card(
ui.ctx(),
egui::Id::unique("render_frame_size_chip"),
frame.left_top() + vec2(t.space_8, t.space_8),
egui::Align2::LEFT_TOP,
|ui| {
ui_kit::text(ui, &label, ui_kit::Text::Inline);
},
);
let lens = if app.cam.fov > 0.0 {
// Full-frame equivalent using the vertical 24 mm sensor dimension.
let mm = 12.0 / (app.cam.fov / 2.0).tan();
crate::i18n::format("render.frame_lens", &[("fov", &format!("{:.0}", app.cam.fov.to_degrees())), ("mm", &format!("{mm:.0}"))])
} else {
app.tr("render.stage_orthographic").to_string()
};
ui_kit::Container::navigation_card(
ui.ctx(),
egui::Id::unique("render_frame_lens_chip"),
pos2(frame.left() + t.space_8, frame.bottom() - t.space_8),
egui::Align2::LEFT_BOTTOM,
|ui| {
ui_kit::text(ui, &lens, ui_kit::Text::Inline);
},
);
}