2 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. -d63aa814fjyviko: threads: main's tapped-hole sizes and shaft turn-down on the reworked thread -cfc393d68jyviko: Main's new callers of the placing calls that now return their error Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
710 lines
33 KiB
Rust
710 lines
33 KiB
Rust
//! Transient CPU image controls; engine commands own file capture and admission.
|
||
use serde_json::{Value, json};
|
||
use solidcraft_engine::render::job::{
|
||
CpuBudget, DirectionalLightOptions, PunctualLightOptions, RaytraceEnvironmentOptions, ReflectionBody, ReflectionMode,
|
||
};
|
||
|
||
use super::hdr;
|
||
use crate::{SolveApp, ui_kit};
|
||
|
||
pub(super) fn validate_progressive_image(app: &SolveApp) -> Result<(), String> {
|
||
if app.render_workspace.view.method == super::ImageMethod::CpuRaytrace {
|
||
let view = &app.render_workspace.view;
|
||
view.raytrace.budget.validate_image(view.draft.width, view.draft.height, view.raytrace.progressive).map_err(|error| error.to_string())?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub(super) fn image_limits(app: &SolveApp) -> solidcraft_engine::render::RenderLimits {
|
||
if app.render_workspace.view.method == super::ImageMethod::GpuRaytrace {
|
||
return solidcraft_engine::render::job::GPU_PATH_LIMITS;
|
||
}
|
||
if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace {
|
||
return Default::default();
|
||
}
|
||
let options = &app.render_workspace.view.raytrace;
|
||
let mut limits = options.budget.image_limits(options.progressive.is_some());
|
||
if let Some(progressive) = options.progressive {
|
||
limits.max_pixels = limits.max_pixels.min(options.budget.limits().max_camera_samples / u64::from(progressive.samples_per_pixel.max(1)));
|
||
}
|
||
limits
|
||
}
|
||
|
||
fn budget_key(budget: CpuBudget) -> &'static str {
|
||
match budget {
|
||
CpuBudget::Compact => "render.cpu_budget_compact",
|
||
CpuBudget::Studio => "render.cpu_budget_studio",
|
||
CpuBudget::Workstation => "render.cpu_budget_workstation",
|
||
}
|
||
}
|
||
|
||
fn budget_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
ui.label(app.tr("render.cpu_budget"));
|
||
let selected = app.render_workspace.view.raytrace.budget;
|
||
let label = app.tr(budget_key(selected)).to_string();
|
||
let control = ui_kit::dropdown_menu(ui, "render_cpu_budget", &label, |ui| {
|
||
for budget in CpuBudget::ALL {
|
||
let key = budget_key(budget);
|
||
let response = ui_kit::list_picker(ui, key, app.tr(key), budget == selected);
|
||
crate::scenario::publish_handle(key, response.rect.center());
|
||
if response.clicked() {
|
||
// Preserve incompatible dimensions/samples for explicit correction.
|
||
app.render_workspace.view.raytrace.budget = budget;
|
||
app.render_workspace.view.dirty = true;
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
crate::scenario::publish_target("render:cpu-budget", control.rect);
|
||
ui.small(app.tr("render.cpu_budget_help"));
|
||
let title = app.tr("render.cpu_budget_details").to_string();
|
||
ui_kit::section(ui, "render_cpu_budget_details", &title, false, |ui| {
|
||
let limits = app.render_workspace.view.raytrace.budget.limits();
|
||
ui.label(format!("{}: {:.2} GiB", app.tr("render.cpu_budget_memory"), limits.max_job_bytes as f64 / 1_073_741_824.0));
|
||
ui.label(format!("{}: {}", app.tr("render.cpu_budget_triangles"), limits.max_triangles));
|
||
ui.label(format!("{}: {}", app.tr("render.cpu_budget_bodies"), limits.max_bodies));
|
||
ui.label(format!("{}: {}", app.tr("render.cpu_progressive_spp"), limits.max_samples_per_pixel));
|
||
ui.small(app.tr("render.cpu_budget_not_guarantee"));
|
||
});
|
||
}
|
||
|
||
fn set_progressive(app: &mut SolveApp, enabled: bool) {
|
||
let options = &mut app.render_workspace.view.raytrace;
|
||
if enabled {
|
||
options.progressive.get_or_insert_default();
|
||
options.primary_samples = 1;
|
||
} else {
|
||
options.progressive = None;
|
||
}
|
||
app.render_workspace.view.dirty = true;
|
||
}
|
||
|
||
pub(super) fn progressive_controls(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
|
||
budget_controls(app, ui);
|
||
ui.label(app.tr("render.cpu_sampling_mode"));
|
||
let selected = app.render_workspace.view.raytrace.progressive.is_some();
|
||
let label = app.tr(if selected { "render.cpu_progressive" } else { "render.cpu_fixed" }).to_string();
|
||
let response = ui_kit::dropdown_menu(ui, "render_cpu_sampling", &label, |ui| {
|
||
for (enabled, key, handle) in [(false, "render.cpu_fixed", "render:cpu-fixed"), (true, "render.cpu_progressive", "render:cpu-progressive")] {
|
||
let response = ui_kit::list_picker(ui, handle, app.tr(key), selected == enabled);
|
||
crate::scenario::publish_handle(handle, response.rect.center());
|
||
if response.clicked() {
|
||
set_progressive(app, enabled);
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
crate::scenario::publish_handle("render:cpu-sampling", response.rect.center());
|
||
let spp = app.tr("render.cpu_progressive_spp").to_string();
|
||
let seed = app.tr("render.cpu_progressive_seed").to_string();
|
||
if let Some(options) = &mut app.render_workspace.view.raytrace.progressive {
|
||
ui.label(spp);
|
||
let response = ui_kit::number_field(ui, &mut options.samples_per_pixel, 1..=4096, 1.0, "");
|
||
app.render_workspace.view.dirty |= response.changed();
|
||
crate::scenario::publish_handle("render:cpu-spp", response.rect.center());
|
||
ui.label(seed);
|
||
let response = ui_kit::number_field(ui, &mut options.seed, 0..=u32::MAX, 1.0, "");
|
||
app.render_workspace.view.dirty |= response.changed();
|
||
crate::scenario::publish_handle("render:cpu-seed", response.rect.center());
|
||
ui.small(app.tr("render.cpu_progressive_help"));
|
||
if app.render_workspace.view.raytrace.budget == CpuBudget::Compact {
|
||
ui.small(app.tr("render.cpu_progressive_limits"));
|
||
} else {
|
||
ui.small(app.tr("render.cpu_budget_not_guarantee"));
|
||
}
|
||
return true;
|
||
}
|
||
false
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||
pub(super) enum Environment {
|
||
#[default]
|
||
None,
|
||
Constant,
|
||
Hdr,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub(super) struct View {
|
||
pub selected_body: Option<String>,
|
||
pub body_filter: String,
|
||
pub environment: Environment,
|
||
pub hdr: hdr::Input,
|
||
pub rotation_rad: f64,
|
||
pub intensity: f64,
|
||
pub samples: u32,
|
||
pub color: [f64; 3],
|
||
pub checked: Option<Checked>,
|
||
bindings: std::collections::BTreeMap<String, Binding>,
|
||
}
|
||
|
||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||
struct Target {
|
||
ordinal: usize,
|
||
feature: u64,
|
||
component: u64,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
struct Binding {
|
||
target: Target,
|
||
revision: u64,
|
||
document: std::sync::Weak<solidcraft_engine::doc::Document>,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub(super) struct Checked {
|
||
pub request: Value,
|
||
pub revision: u64,
|
||
pub environment: Value,
|
||
document: std::sync::Weak<solidcraft_engine::doc::Document>,
|
||
}
|
||
|
||
impl Default for View {
|
||
fn default() -> Self {
|
||
Self {
|
||
selected_body: None,
|
||
body_filter: String::new(),
|
||
environment: Environment::None,
|
||
hdr: hdr::Input::default(),
|
||
rotation_rad: 0.0,
|
||
intensity: 1.0,
|
||
samples: 16,
|
||
color: [1.0; 3],
|
||
checked: None,
|
||
bindings: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn valid_name(name: &str) -> bool {
|
||
!name.is_empty() && name.len() <= 128 && !name.chars().any(char::is_control)
|
||
}
|
||
|
||
fn target(app: &SolveApp, name: &str) -> Option<Target> {
|
||
if !valid_name(name) || app.session.model.is_stale() {
|
||
return None;
|
||
}
|
||
let world = crate::open_meshing::session_world(&app.session);
|
||
let mut matches = world.bodies.iter().filter(|body| app.session.body_visible(&body.name)).enumerate().filter(|(_, body)| body.name == name);
|
||
let (ordinal, body) = matches.next()?;
|
||
if matches.next().is_some() {
|
||
return None;
|
||
}
|
||
Some(Target { ordinal, feature: body.feature, component: body.component })
|
||
}
|
||
|
||
fn unique_visible_body(app: &SolveApp, name: &str) -> bool {
|
||
target(app, name).is_some()
|
||
}
|
||
|
||
fn binding_current(app: &SolveApp, name: &str) -> bool {
|
||
app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| {
|
||
binding.revision == app.session.revision
|
||
&& std::sync::Weak::ptr_eq(&binding.document, &std::sync::Arc::downgrade(&app.session.doc))
|
||
&& target(app, name).as_ref() == Some(&binding.target)
|
||
})
|
||
}
|
||
|
||
pub(super) fn revalidate(app: &mut SolveApp, name: &str) -> Result<(), String> {
|
||
let current = target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?;
|
||
if app.render_workspace.view.cpu.bindings.get(name).is_none_or(|binding| binding.target != current) {
|
||
return Err(app.tr("render.cpu_body_missing").to_string());
|
||
}
|
||
let revision = app.session.revision;
|
||
let document = std::sync::Arc::downgrade(&app.session.doc);
|
||
if let Some(binding) = app.render_workspace.view.cpu.bindings.get_mut(name) {
|
||
binding.revision = revision;
|
||
binding.document = document;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// A removed, hidden or ambiguous body never silently becomes a different target.
|
||
pub(super) fn set_reflection(app: &mut SolveApp, name: &str, mode: Option<ReflectionMode>) -> Result<(), String> {
|
||
let selected = if mode.is_some() { Some(target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?) } else { None };
|
||
// Changing the mode of an existing row is not a new body selection. Only an
|
||
// explicit confirmation of the same target, or Off followed by Add, may
|
||
// establish a fresh binding after the document or body identity changes.
|
||
if mode.is_some()
|
||
&& app.render_workspace.view.raytrace.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| entry.body == name))
|
||
&& !binding_current(app, name)
|
||
{
|
||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||
}
|
||
let message = app.tr("render.cpu_reflection_limit").to_string();
|
||
let options = &mut app.render_workspace.view.raytrace;
|
||
if let Some(mode) = mode {
|
||
let mut reflections = options.reflections.clone().unwrap_or_default();
|
||
if let Some(entry) = reflections.bodies.iter_mut().find(|entry| entry.body == name) {
|
||
entry.mode = mode;
|
||
} else {
|
||
if reflections.bodies.len() >= 64 {
|
||
return Err(message);
|
||
}
|
||
reflections.bodies.try_reserve_exact(1).map_err(|_| message.clone())?;
|
||
if reflections.bodies.capacity() > 64 {
|
||
return Err(message);
|
||
}
|
||
reflections.bodies.push(ReflectionBody { body: name.to_string(), mode });
|
||
}
|
||
options.reflections = Some(reflections);
|
||
} else if let Some(reflections) = &mut options.reflections {
|
||
reflections.bodies.retain(|entry| entry.body != name);
|
||
if reflections.bodies.is_empty() {
|
||
options.reflections = None;
|
||
}
|
||
}
|
||
if let Some(target) = selected {
|
||
app.render_workspace
|
||
.view
|
||
.cpu
|
||
.bindings
|
||
.insert(name.to_string(), Binding { target, revision: app.session.revision, document: std::sync::Arc::downgrade(&app.session.doc) });
|
||
} else {
|
||
app.render_workspace.view.cpu.bindings.remove(name);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Shared by the parent Check and Start builder. This does not read an HDR file.
|
||
pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> {
|
||
let base = &app.render_workspace.view.raytrace;
|
||
if base.anisotropic_faces.iter().any(Option::is_some)
|
||
|| !base.dielectrics.is_empty()
|
||
|| base.environment.is_some()
|
||
|| base.surface_effects.is_some()
|
||
|| base.emissions.is_some()
|
||
{
|
||
return Err(app.tr("render.cpu_options_pending").to_string());
|
||
}
|
||
if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !unique_visible_body(app, &entry.body))) {
|
||
return Err(app.tr("render.cpu_body_missing").to_string());
|
||
}
|
||
if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !binding_current(app, &entry.body))) {
|
||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||
}
|
||
let view = &app.render_workspace.view.cpu;
|
||
let mut options = base.clone();
|
||
if options.area_samples.is_some_and(|n| !matches!(n, 1 | 4 | 16 | 64)) {
|
||
return Err("area_samples must be 1, 4, 16 or 64".into());
|
||
}
|
||
if options.area_lights.as_ref().is_none_or(Vec::is_empty) {
|
||
options.area_samples = None;
|
||
options.seed = None;
|
||
}
|
||
options.exposure_ev = app.render_workspace.view.draft.exposure_ev;
|
||
// Runtime CPU requests keep the same single saved EV authority as typed jobs.
|
||
params["settings"]["exposure_ev"] = json!(0.0);
|
||
if view.environment != Environment::None {
|
||
if !view.intensity.is_finite() || !(0.0..=64.0).contains(&view.intensity) {
|
||
return Err(app.tr("render.cpu_environment_bounds").to_string());
|
||
}
|
||
match view.environment {
|
||
Environment::Constant => options.environment = Some(RaytraceEnvironmentOptions { color: view.color, intensity: view.intensity }),
|
||
Environment::Hdr => {
|
||
if !view.rotation_rad.is_finite() || view.rotation_rad.abs() > 1e6 || !matches!(view.samples, 1 | 4 | 16 | 64) {
|
||
return Err(app.tr("render.cpu_environment_bounds").to_string());
|
||
}
|
||
let mut environment = hdr::request(app, hdr::Target::Cpu)?;
|
||
environment["rotation_radians"] = json!(view.rotation_rad);
|
||
environment["intensity"] = json!(view.intensity);
|
||
environment["samples"] = json!(view.samples);
|
||
params["environment"] = environment;
|
||
}
|
||
Environment::None => {}
|
||
}
|
||
}
|
||
options.validate().map_err(|error| error.to_string())?;
|
||
params["integrator"] = json!("raytrace");
|
||
params["raytrace"] = json!(options);
|
||
Ok(())
|
||
}
|
||
|
||
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
for (id, key, section) in [
|
||
("render_cpu_reflections", "render.cpu_reflections", 0),
|
||
("render_cpu_environment", "render.cpu_environment", 1),
|
||
("render_cpu_lights", "render.cpu_lights", 2),
|
||
] {
|
||
let title = app.tr(key).to_string();
|
||
ui_kit::section(ui, id, &title, false, |ui| match section {
|
||
0 => reflection_controls(app, ui),
|
||
1 => environment_controls(app, ui),
|
||
_ => light_controls(app, ui),
|
||
});
|
||
}
|
||
ui.small(app.tr("render.cpu_runtime_help"));
|
||
}
|
||
|
||
pub(super) fn reflection_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
ui.small(app.tr("render.cpu_reflection_help"));
|
||
let entries = app.render_workspace.view.raytrace.reflections.as_ref().map(|r| r.bodies.clone()).unwrap_or_default();
|
||
for entry in entries {
|
||
ui.label(&entry.body);
|
||
if !binding_current(app, &entry.body) {
|
||
ui.small(app.tr("render.cpu_binding_stale"));
|
||
if ui_kit::button(ui, app.tr("render.cpu_binding_confirm"), ui_kit::Button::Normal).clicked()
|
||
&& let Err(error) = revalidate(app, &entry.body)
|
||
{
|
||
app.set_status(error, true);
|
||
}
|
||
}
|
||
let selected = match entry.mode {
|
||
ReflectionMode::Mirror => "render.cpu_reflection_mirror",
|
||
ReflectionMode::RoughSpecular => "render.cpu_reflection_rough",
|
||
};
|
||
let label = app.tr(selected).to_string();
|
||
let mode_control = ui_kit::dropdown_menu(ui, ("cpu_reflection_mode", &entry.body), &label, |ui| {
|
||
for (mode, key) in [
|
||
(None, "render.cpu_reflection_off"),
|
||
(Some(ReflectionMode::Mirror), "render.cpu_reflection_mirror"),
|
||
(Some(ReflectionMode::RoughSpecular), "render.cpu_reflection_rough"),
|
||
] {
|
||
let enabled = mode.is_none() || binding_current(app, &entry.body);
|
||
if ui.add_enabled_ui(enabled, |ui| ui_kit::list_picker(ui, key, app.tr(key), mode == Some(entry.mode))).inner.clicked() {
|
||
if let Err(error) = set_reflection(app, &entry.body, mode) {
|
||
app.set_status(error, true);
|
||
}
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
crate::scenario::publish_handle(&format!("render:cpu-reflection-mode:{}", entry.body), mode_control.rect.center());
|
||
}
|
||
let hint = app.tr("render.cpu_body_filter").to_string();
|
||
ui_kit::bounded_cell_editor(ui, ui.id().with("cpu_body_filter"), &mut app.render_workspace.view.cpu.body_filter, &hint, false, 128);
|
||
let selected = app.render_workspace.view.cpu.selected_body.clone();
|
||
let label = selected.clone().unwrap_or_else(|| app.tr("render.cpu_body_choose").to_string());
|
||
let world = crate::open_meshing::session_world(&app.session);
|
||
let filter = app.render_workspace.view.cpu.body_filter.to_lowercase();
|
||
let candidates: Vec<_> = world
|
||
.bodies
|
||
.iter()
|
||
.filter(|body| app.session.body_visible(&body.name) && body.name.to_lowercase().contains(&filter))
|
||
.take(257)
|
||
.map(|body| body.name.as_str())
|
||
.collect();
|
||
let dropdown = ui_kit::dropdown_menu(ui, "cpu_reflection_body", &label, |ui| {
|
||
egui::ScrollArea::vertical().max_height(240.0).show(ui, |ui| {
|
||
for (shown, name) in candidates.iter().enumerate() {
|
||
if shown == 256 {
|
||
ui.small(app.tr("render.cpu_body_filter_more"));
|
||
break;
|
||
}
|
||
let response =
|
||
ui.add_enabled_ui(valid_name(name), |ui| ui_kit::list_picker(ui, name, name, selected.as_deref() == Some(*name))).inner;
|
||
if response.clicked() {
|
||
app.render_workspace.view.cpu.selected_body = Some((*name).to_string());
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
});
|
||
crate::scenario::publish_handle("render:cpu-reflection-body", dropdown.rect.center());
|
||
let can_add = selected.as_ref().is_some_and(|name| unique_visible_body(app, name))
|
||
&& app.render_workspace.view.raytrace.reflections.as_ref().is_none_or(|r| r.bodies.len() < 64);
|
||
let add = ui_kit::button(ui, app.tr("render.cpu_reflection_add"), ui_kit::Button::Enabled(can_add));
|
||
crate::scenario::publish_handle("render:cpu-reflection-add", add.rect.center());
|
||
if add.clicked()
|
||
&& let Some(name) = selected
|
||
&& let Err(error) = set_reflection(app, &name, Some(ReflectionMode::RoughSpecular))
|
||
{
|
||
app.set_status(error, true);
|
||
}
|
||
let depth = app.tr("render.cpu_reflection_depth").to_string();
|
||
let samples = app.tr("render.cpu_reflection_samples").to_string();
|
||
if let Some(reflections) = &mut app.render_workspace.view.raytrace.reflections {
|
||
ui.label(depth);
|
||
ui_kit::number_field(ui, &mut reflections.max_bounces, 1..=8, 1.0, "");
|
||
ui.label(samples);
|
||
ui_kit::number_field(ui, &mut reflections.samples, 1..=64, 1.0, "");
|
||
} else {
|
||
ui.small(app.tr("render.cpu_reflection_empty"));
|
||
}
|
||
}
|
||
|
||
pub(super) fn environment_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let selected = app.render_workspace.view.cpu.environment;
|
||
let key = match selected {
|
||
Environment::None => "render.cpu_environment_none",
|
||
Environment::Constant => "render.cpu_environment_constant",
|
||
Environment::Hdr => "render.studio_hdr",
|
||
};
|
||
let label = app.tr(key).to_string();
|
||
ui_kit::dropdown_menu(ui, "cpu_environment_kind", &label, |ui| {
|
||
for (value, key) in [
|
||
(Environment::None, "render.cpu_environment_none"),
|
||
(Environment::Constant, "render.cpu_environment_constant"),
|
||
(Environment::Hdr, "render.studio_hdr"),
|
||
] {
|
||
if ui_kit::list_picker(ui, key, app.tr(key), value == selected).clicked() {
|
||
app.render_workspace.view.cpu.environment = value;
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
if app.render_workspace.view.cpu.environment == Environment::None {
|
||
return;
|
||
}
|
||
if app.render_workspace.view.cpu.environment == Environment::Constant {
|
||
let color = app.tr("render.cpu_linear_color").to_string();
|
||
vector(ui, &color, &mut app.render_workspace.view.cpu.color, 0.0..=1.0, 0.01, "");
|
||
ui.small(app.tr("render.cpu_constant_help"));
|
||
} else {
|
||
hdr::controls(app, ui, hdr::Target::Cpu);
|
||
ui.small(app.tr("render.cpu_hdr_help"));
|
||
ui.label(app.tr("render.studio_rotation"));
|
||
let mut degrees = app.render_workspace.view.cpu.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.cpu.rotation_rad = degrees.to_radians();
|
||
}
|
||
ui.label(app.tr("render.cpu_environment_samples"));
|
||
let samples = app.render_workspace.view.cpu.samples;
|
||
ui_kit::dropdown_menu(ui, "cpu_hdr_samples", &samples.to_string(), |ui| {
|
||
for value in [1, 4, 16, 64] {
|
||
if ui_kit::list_picker(ui, &value.to_string(), &value.to_string(), value == samples).clicked() {
|
||
app.render_workspace.view.cpu.samples = value;
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
ui.small(app.tr("render.cpu_hdr_reflection_help"));
|
||
}
|
||
ui.label(app.tr("render.studio_intensity"));
|
||
ui_kit::number_field(ui, &mut app.render_workspace.view.cpu.intensity, 0.0..=64.0, 0.1, "");
|
||
ui.small(app.tr("render.cpu_environment_background"));
|
||
}
|
||
|
||
fn vector(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, speed: f64, suffix: &str) {
|
||
ui.label(label);
|
||
ui.horizontal(|ui| {
|
||
for component in value {
|
||
ui_kit::number_field(ui, component, range.clone(), speed, suffix);
|
||
}
|
||
});
|
||
}
|
||
|
||
pub(super) fn light_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let mut custom = app.render_workspace.view.raytrace.lights.is_some();
|
||
if ui_kit::checkbox(ui, app.tr("render.cpu_custom_directions"), &mut custom).changed() {
|
||
let options = &mut app.render_workspace.view.raytrace;
|
||
options.lights = custom.then(Vec::new);
|
||
if custom {
|
||
options.preset = None;
|
||
}
|
||
}
|
||
ui.small(app.tr("render.cpu_light_help"));
|
||
let title = app.tr("render.cpu_directional").to_string();
|
||
let mut remove = None;
|
||
let count = app.render_workspace.view.raytrace.lights.as_ref().map_or(0, Vec::len);
|
||
for index in 0..count {
|
||
ui_kit::section(ui, ("cpu_directional", index), &format!("{title} {}", index + 1), false, |ui| {
|
||
let direction = app.tr("render.cpu_direction").to_string();
|
||
let color = app.tr("render.cpu_linear_color").to_string();
|
||
let intensity = app.tr("render.cpu_light_intensity").to_string();
|
||
if let Some(light) = app.render_workspace.view.raytrace.lights.as_mut().and_then(|lights| lights.get_mut(index)) {
|
||
vector(ui, &direction, &mut light.direction, -f64::MAX..=f64::MAX, 0.01, "");
|
||
vector(ui, &color, &mut light.color, 0.0..=1.0, 0.01, "");
|
||
ui.label(intensity);
|
||
ui_kit::number_field(ui, &mut light.intensity, 0.0..=64.0, 0.1, "");
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.cpu_light_remove"), ui_kit::Button::Normal).clicked() {
|
||
remove = Some(index);
|
||
}
|
||
});
|
||
}
|
||
if let Some(index) = remove
|
||
&& let Some(lights) = &mut app.render_workspace.view.raytrace.lights
|
||
&& index < lights.len()
|
||
{
|
||
lights.remove(index);
|
||
}
|
||
if custom
|
||
&& ui_kit::button(ui, app.tr("render.cpu_directional_add"), ui_kit::Button::Enabled(count < 8)).clicked()
|
||
&& let Some(lights) = &mut app.render_workspace.view.raytrace.lights
|
||
{
|
||
lights.push(DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 });
|
||
}
|
||
let title = app.tr("render.cpu_point").to_string();
|
||
let mut remove = None;
|
||
let count = app.render_workspace.view.raytrace.punctual_lights.as_ref().map_or(0, Vec::len);
|
||
for index in 0..count {
|
||
ui_kit::section(ui, ("cpu_point", index), &format!("{title} {}", index + 1), false, |ui| {
|
||
let position = app.tr("render.cpu_light_position").to_string();
|
||
let color = app.tr("render.cpu_linear_color").to_string();
|
||
let intensity = app.tr("render.cpu_light_intensity").to_string();
|
||
let reference = app.tr("render.cpu_light_reference").to_string();
|
||
let minimum = app.tr("render.cpu_light_minimum").to_string();
|
||
if let Some(light) = app.render_workspace.view.raytrace.punctual_lights.as_mut().and_then(|lights| lights.get_mut(index)) {
|
||
vector(ui, &position, &mut light.position_mm, -1e12..=1e12, 1.0, " mm");
|
||
vector(ui, &color, &mut light.color, 0.0..=1.0, 0.01, "");
|
||
ui.label(intensity);
|
||
ui_kit::number_field(ui, &mut light.intensity, 0.0..=64.0, 0.1, "");
|
||
ui.label(reference);
|
||
ui_kit::number_field(ui, &mut light.reference_distance_mm, 0.001..=1e6, 1.0, " mm");
|
||
ui.label(minimum);
|
||
ui_kit::number_field(ui, &mut light.minimum_distance_mm, 0.001..=1e6, 0.01, " mm");
|
||
let mut spot = light.cone.is_some();
|
||
if ui_kit::checkbox(ui, "Spot cone", &mut spot).changed() {
|
||
light.cone = spot.then_some(solidcraft_engine::render::job::SpotConeOptions {
|
||
emitted_axis: [0.0, 0.0, -1.0],
|
||
inner_half_angle_radians: 0.2,
|
||
outer_half_angle_radians: 0.5,
|
||
});
|
||
}
|
||
if let Some(cone) = &mut light.cone {
|
||
vector(ui, "Emitted axis", &mut cone.emitted_axis, -1e8..=1e8, 0.01, "");
|
||
for (label, value) in
|
||
[("Inner half angle", &mut cone.inner_half_angle_radians), ("Outer half angle", &mut cone.outer_half_angle_radians)]
|
||
{
|
||
ui.label(label);
|
||
let mut degrees = value.to_degrees();
|
||
if ui_kit::number_field(ui, &mut degrees, 0.0..=90.0, 0.1, " deg").changed() {
|
||
*value = degrees.to_radians();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.cpu_light_remove"), ui_kit::Button::Normal).clicked() {
|
||
remove = Some(index);
|
||
}
|
||
});
|
||
}
|
||
if let Some(index) = remove
|
||
&& let Some(lights) = &mut app.render_workspace.view.raytrace.punctual_lights
|
||
&& index < lights.len()
|
||
{
|
||
lights.remove(index);
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.cpu_point_add"), ui_kit::Button::Enabled(count < 8)).clicked() {
|
||
let p = app.cam.target;
|
||
let height = app.cam.distance.clamp(1.0, 1e6);
|
||
app.render_workspace.view.raytrace.punctual_lights.get_or_insert_default().push(PunctualLightOptions {
|
||
position_mm: [p.x, p.y, p.z + height],
|
||
color: [1.0; 3],
|
||
intensity: 1.0,
|
||
reference_distance_mm: height,
|
||
minimum_distance_mm: 0.001,
|
||
cone: None,
|
||
});
|
||
}
|
||
ui.small(app.tr("render.cpu_point_help"));
|
||
area_controls(app, ui);
|
||
}
|
||
|
||
pub(super) fn record_checked(app: &mut SolveApp, params: &Value, reply: &Value) {
|
||
if params["integrator"] == "raytrace" || params["settings"]["job"]["method"] == "cpu_raytrace" {
|
||
app.render_workspace.view.cpu.checked = Some(Checked {
|
||
request: params.clone(),
|
||
revision: app.session.revision,
|
||
environment: reply["environment"].clone(),
|
||
document: std::sync::Arc::downgrade(&app.session.doc),
|
||
});
|
||
}
|
||
}
|
||
|
||
fn metadata(app: &SolveApp, ui: &mut egui::Ui, info: &Value) {
|
||
let Some(hash) = info["source_sha256"].as_array().filter(|hash| hash.len() == 32) else { return };
|
||
let digest: Option<Vec<_>> = hash.iter().map(|byte| byte.as_u64().and_then(|n| u8::try_from(n).ok())).collect();
|
||
let Some(digest) = digest else { return };
|
||
let digest: String = digest.into_iter().map(|byte| format!("{byte:02x}")).collect();
|
||
let width = info["header"]["width"].as_u64().unwrap_or(0);
|
||
let height = info["header"]["height"].as_u64().unwrap_or(0);
|
||
ui.label(format!("{width} × {height} px"));
|
||
ui.label(format!("{}: {}", app.tr("render.cpu_environment_samples"), info["samples"].as_u64().unwrap_or(0)));
|
||
ui.label(format!("{}: {:.2}", app.tr("render.studio_intensity"), info["intensity"].as_f64().unwrap_or(0.0)));
|
||
ui.label(format!("{}: {:.1}°", app.tr("render.studio_rotation"), info["rotation_radians"].as_f64().unwrap_or(0.0).to_degrees()));
|
||
ui.label(format!("SHA-256: {digest}"));
|
||
}
|
||
|
||
pub(super) fn checked_status(app: &SolveApp, ui: &mut egui::Ui, params: Option<&Value>) {
|
||
if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace {
|
||
return;
|
||
}
|
||
if let Some(checked) = &app.render_workspace.view.cpu.checked {
|
||
let title = app.tr("render.cpu_last_check").to_string();
|
||
ui_kit::section(ui, "cpu_last_check", &title, false, |ui| {
|
||
if params != Some(&checked.request)
|
||
|| checked.revision != app.session.revision
|
||
|| !std::sync::Weak::ptr_eq(&checked.document, &std::sync::Arc::downgrade(&app.session.doc))
|
||
{
|
||
ui.small(app.tr("render.cpu_check_changed"));
|
||
}
|
||
metadata(app, ui, &checked.environment);
|
||
ui.small(app.tr("render.cpu_check_capture_help"));
|
||
});
|
||
}
|
||
}
|
||
|
||
pub(super) fn captured_status(app: &SolveApp, ui: &mut egui::Ui, status: &Value) {
|
||
if status["request"]["integrator"] == "raytrace" && status["environment"]["source_sha256"].is_array() {
|
||
let title = app.tr("render.cpu_captured_hdr").to_string();
|
||
ui_kit::section(ui, "cpu_captured_hdr", &title, false, |ui| metadata(app, ui, &status["environment"]));
|
||
}
|
||
}
|
||
|
||
fn area_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||
let title = app.tr("render.cpu_area_editor").to_string();
|
||
ui_kit::section(ui, "render_cpu_areas", &title, false, |ui| {
|
||
ui.small(app.tr("render.cpu_area_editor_help"));
|
||
let count = app.render_workspace.view.raytrace.area_lights.as_ref().map_or(0, Vec::len);
|
||
let mut remove = None;
|
||
for index in 0..count {
|
||
ui_kit::section(ui, ("render_cpu_area", index), &format!("{} {}", title, index + 1), false, |ui| {
|
||
let position = app.tr("render.cpu_light_position").to_string();
|
||
let u = app.tr("render.cpu_area_full_u").to_string();
|
||
let v = app.tr("render.cpu_area_full_v").to_string();
|
||
let color = app.tr("render.cpu_linear_color").to_string();
|
||
let intensity = app.tr("render.cpu_light_intensity").to_string();
|
||
if let Some(light) = app.render_workspace.view.raytrace.area_lights.as_mut().and_then(|lights| lights.get_mut(index)) {
|
||
vector(ui, &position, &mut light.center_mm, -1e12..=1e12, 1.0, " mm");
|
||
vector(ui, &u, &mut light.edge_u_mm, -1e6..=1e6, 1.0, " mm");
|
||
vector(ui, &v, &mut light.edge_v_mm, -1e6..=1e6, 1.0, " mm");
|
||
vector(ui, &color, &mut light.color, 0.0..=1.0, 0.01, "");
|
||
ui.label(intensity);
|
||
ui_kit::number_field(ui, &mut light.intensity, 0.0..=64.0, 0.1, "");
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.cpu_light_remove"), ui_kit::Button::Normal).clicked() {
|
||
remove = Some(index);
|
||
}
|
||
});
|
||
}
|
||
if let Some(index) = remove
|
||
&& let Some(lights) = &mut app.render_workspace.view.raytrace.area_lights
|
||
&& index < lights.len()
|
||
{
|
||
lights.remove(index);
|
||
}
|
||
if ui_kit::button(ui, app.tr("render.cpu_area_add"), ui_kit::Button::Enabled(count < solidcraft_engine::render::job::MAX_AREA_LIGHTS))
|
||
.clicked()
|
||
{
|
||
let center = app.cam.target;
|
||
let size = app.cam.distance.clamp(1.0, 1e6) * 0.25;
|
||
let options = &mut app.render_workspace.view.raytrace;
|
||
options.area_lights.get_or_insert_default().push(solidcraft_engine::render::job::RectangleLightOptions {
|
||
center_mm: [center.x, center.y, center.z + size * 3.0],
|
||
edge_u_mm: [size, 0.0, 0.0],
|
||
edge_v_mm: [0.0, -size, 0.0],
|
||
color: [1.0; 3],
|
||
intensity: 1.0,
|
||
});
|
||
options.area_samples.get_or_insert(16);
|
||
options.seed.get_or_insert(0);
|
||
}
|
||
if app.render_workspace.view.raytrace.area_lights.as_ref().is_some_and(|v| !v.is_empty()) {
|
||
let value = app.render_workspace.view.raytrace.area_samples.unwrap_or(16);
|
||
ui.label(app.tr("render.cpu_area_samples"));
|
||
ui_kit::dropdown_menu(ui, "cpu_area_samples", &value.to_string(), |ui| {
|
||
for count in [1, 4, 16, 64] {
|
||
if ui_kit::list_picker(ui, &count.to_string(), &count.to_string(), count == value).clicked() {
|
||
app.render_workspace.view.raytrace.area_samples = Some(count);
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
});
|
||
}
|