Skip to content

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

72.0 KB
Raw Blame
//! Shared body-level optical editing: transient request overlays and explicit
//! stable saved bindings. Engineering geometry/materials never change here.
use solidcore_record::Vec3;
use std::sync::{Arc, Weak};

use serde::Deserialize;
use serde_json::{Value, json};
use solidcraft_engine::{
    doc::{
        Document,
        appearance_pack::{self, GlassBoundary, Recipe},
    },
    render::{
        clear_coat::ClearCoat,
        job::textures::{BaseColorMode, PlanarFrame},
        surface::OpaqueSurface,
        transmission::Transmission,
    },
};

#[cfg(test)]
use crate::theme::Tokens;
use crate::{SolveApp, ui_kit};

const MAX_BINDINGS: usize = 128;

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub(super) struct Target {
    #[serde(default)]
    pub stable_target: Option<solidcraft_engine::doc::render_surface::RenderBodyTarget>,
    pub ordinal: usize,
    pub name: String,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(super) enum Boundary {
    Thin,
    Box,
    #[default]
    Closed,
}
impl Boundary {
    fn wire(self) -> &'static str {
        match self {
            Self::Thin => "thin_sheet",
            Self::Box => "closed_box",
            Self::Closed => "closed_mesh",
        }
    }
}

#[derive(Clone, Debug)]
pub(super) struct Glass {
    pub model: Option<solidcraft_engine::render::glass_model::GlassModel>,
    pub recipe: Option<&'static str>,
    pub ior: f64,
    pub absorption: [f64; 3],
    pub boundary: Boundary,
    pub thickness: f64,
    pub shadows: bool,
    pub subsurface: Option<solidcraft_engine::render::transmission::subsurface::Subsurface>,
}
impl Default for Glass {
    fn default() -> Self {
        Self {
            model: None,
            recipe: None,
            ior: 1.5,
            absorption: [0.0; 3],
            boundary: Boundary::Closed,
            thickness: 1.0,
            shadows: false,
            subsurface: None,
        }
    }
}
impl Glass {
    pub(super) fn recipe(id: &str) -> Result<Self, String> {
        let preset = appearance_pack::find(id).ok_or_else(|| crate::i18n::tr("render.error_glass_recipe").to_string())?;
        let Recipe::Glass(recipe) = preset.recipe else { return Err(crate::i18n::tr("render.error_physical_glass").into()) };
        recipe.validate().map_err(|e| e.to_string())?;
        let (boundary, thickness) = match recipe.boundary {
            GlassBoundary::Thin { thickness_mm } => (Boundary::Thin, thickness_mm),
            GlassBoundary::Closed => (Boundary::Closed, 1.0),
        };
        Ok(Self {
            model: None,
            subsurface: None,
            recipe: Some(preset.id),
            ior: recipe.dielectric_ior,
            absorption: recipe.transmission_linear_rgb.map(|t| -t.ln() / recipe.reference_path_mm),
            boundary,
            thickness,
            shadows: boundary == Boundary::Thin,
        })
    }
}

#[derive(Clone, Debug)]
pub(super) struct Coat {
    pub weight: f64,
    pub roughness: f64,
    pub ior: f64,
}
impl Default for Coat {
    fn default() -> Self {
        Self { weight: 1.0, roughness: 0.12, ior: 1.5 }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub(super) struct Maps {
    pub color: String,
    pub normal: String,
    pub roughness: String,
    pub metallic: String,
    pub base_color_mode: BaseColorMode,
    pub flip_v: bool,
    pub strength: f64,
    pub frame: PlanarFrame,
}
impl Default for Maps {
    fn default() -> Self {
        Self {
            color: String::new(),
            normal: String::new(),
            roughness: String::new(),
            metallic: String::new(),
            base_color_mode: BaseColorMode::Modulate,
            flip_v: false,
            strength: 1.0,
            frame: PlanarFrame { origin: [0.0; 3], u: [10.0, 0.0, 0.0], v: [0.0, 10.0, 0.0] },
        }
    }
}

#[derive(Clone, Debug)]
pub(super) struct Binding {
    pub target: Target,
    revision: u64,
    document: Weak<Document>,
    pub enabled: bool,
    pub glass_enabled: bool,
    pub glass: Glass,
    pub coat_enabled: bool,
    pub coat: Coat,
    pub maps_enabled: bool,
    pub maps: Maps,
    replace_saved_optics: bool,
    saved_source: Option<solidcraft_engine::doc::render_optics::OpticalMaterial>,
    saved_coat_source: Option<solidcraft_engine::doc::render_coat::CoatMaterial>,
    coat_edited: bool,
}
impl Binding {
    pub(super) fn new(target: Target, app: &SolveApp) -> Self {
        Self {
            target,
            revision: app.session.revision,
            document: Arc::downgrade(&app.session.doc),
            enabled: true,
            glass_enabled: false,
            glass: Glass::default(),
            coat_enabled: false,
            coat: Coat::default(),
            maps_enabled: false,
            maps: Maps::default(),
            replace_saved_optics: false,
            saved_source: None,
            saved_coat_source: None,
            coat_edited: false,
        }
    }
    pub(super) fn from_saved(target: Target, app: &SolveApp, optics: solidcraft_engine::doc::render_optics::OpticalMaterial) -> Self {
        let mut binding = Self::new(target, app);
        binding.saved_source = Some(optics);
        binding.glass_enabled = true;
        binding.glass = Glass {
            model: optics.model,
            recipe: None,
            ior: optics.ior,
            absorption: optics.absorption_per_mm,
            boundary: match optics.boundary {
                solidcraft_engine::doc::render_optics::OpticalBoundary::ThinSheet => Boundary::Thin,
                solidcraft_engine::doc::render_optics::OpticalBoundary::ClosedBox => Boundary::Box,
                solidcraft_engine::doc::render_optics::OpticalBoundary::ClosedMesh => Boundary::Closed,
            },
            thickness: if optics.boundary == solidcraft_engine::doc::render_optics::OpticalBoundary::ThinSheet { optics.thickness_mm } else { 1.0 },
            shadows: optics.shadow_transmission,
            subsurface: optics.subsurface,
        };
        binding
    }
    fn hydrate_coat(&mut self, coat: solidcraft_engine::doc::render_coat::CoatMaterial) {
        self.saved_coat_source = Some(coat);
        self.coat_edited = false;
        self.coat_enabled = true;
        self.coat = Coat { weight: coat.weight, roughness: coat.roughness, ior: coat.ior };
    }
    fn coat_has_local_changes(&self) -> bool {
        self.coat_edited
            || if let Some(saved) = self.saved_coat_source {
                !self.enabled || !self.coat_enabled || self.glass_enabled || self.coat_material() != saved
            } else {
                self.coat_enabled
            }
    }
    fn has_local_map_intent(&self) -> bool {
        self.maps_enabled || self.maps != Maps::default()
    }
    fn coat_material(&self) -> solidcraft_engine::doc::render_coat::CoatMaterial {
        solidcraft_engine::doc::render_coat::CoatMaterial { weight: self.coat.weight, roughness: self.coat.roughness, ior: self.coat.ior }
    }
    fn optics(&self) -> solidcraft_engine::doc::render_optics::OpticalMaterial {
        solidcraft_engine::doc::render_optics::OpticalMaterial {
            model: self.glass.model,
            ior: self.glass.ior,
            absorption_per_mm: self.glass.absorption,
            boundary: match self.glass.boundary {
                Boundary::Thin => solidcraft_engine::doc::render_optics::OpticalBoundary::ThinSheet,
                Boundary::Box => solidcraft_engine::doc::render_optics::OpticalBoundary::ClosedBox,
                Boundary::Closed => solidcraft_engine::doc::render_optics::OpticalBoundary::ClosedMesh,
            },
            thickness_mm: if self.glass.boundary == Boundary::Thin { self.glass.thickness } else { 0.0 },
            shadow_transmission: self.glass.shadows,
            subsurface: self.glass.subsurface,
        }
    }
    fn current(&self, app: &SolveApp) -> bool {
        self.revision == app.session.revision && Weak::ptr_eq(&self.document, &Arc::downgrade(&app.session.doc)) && !app.session.model.is_stale()
    }
    fn active(&self) -> bool {
        if let Some(saved) = self.saved_source {
            // Saved edits become a prospective stable request overlay, never
            // an ordinal override or a silent return to the old saved values.
            return !self.enabled || !self.glass_enabled || self.coat_enabled || self.maps_enabled || self.optics() != saved;
        }
        if let Some(saved) = self.saved_coat_source {
            return !self.enabled || !self.coat_enabled || self.glass_enabled || self.maps_enabled || self.coat_material() != saved;
        }
        self.enabled && (self.glass_enabled || self.coat_enabled || self.maps_enabled)
    }
    pub(super) fn has_unsaved_coat_intent(&self) -> bool {
        // Unchanged saved coats never allocate a local binding on paint. A row
        // retained here carries a coat edit or independent local map draft.
        self.coat_enabled || self.saved_coat_source.is_some() || self.coat_edited
    }
    pub(super) fn has_runtime_intent(&self) -> bool {
        // Stable Glass uses the same prospective settings capture as coats.
        // Unknown identities and file maps retain the ordinal runtime route.
        if self.saved_source.is_none() && self.glass_enabled && self.target.stable_target.is_some() && !self.coat_enabled && !self.maps_enabled {
            return false;
        }
        if self.saved_coat_source.is_some() || self.coat_enabled || self.coat_edited {
            self.saved_source.is_none() && (self.glass_enabled || self.maps_enabled)
        } else {
            self.saved_source.is_none()
        }
    }
    fn stable_optics(&self) -> bool {
        self.saved_source.is_some() || (self.glass_enabled && self.target.stable_target.is_some())
    }
    pub(super) fn has_unsaved_optics_intent(&self) -> bool {
        self.stable_optics() && (self.saved_source.is_none() || self.active())
    }
}

#[derive(Clone, Debug, Default)]
pub(super) struct View {
    pub enabled: bool,
    pub bindings: Vec<Binding>,
    targets: Vec<Target>,
    #[cfg(test)]
    target: Option<usize>,
    #[cfg(test)]
    target_search: String,
    selected: Option<usize>,
    target_revision: Option<u64>,
    target_document: Option<Weak<Document>>,
    pending_remove: Option<PendingRemoval>,
}

#[derive(Clone, Debug)]
struct PendingRemoval {
    coat: bool,
    name: String,
    target: solidcraft_engine::doc::render_surface::RenderBodyTarget,
    revision: u64,
    document: Weak<Document>,
}

pub(super) fn read_targets(app: &mut SolveApp) -> Result<Vec<Target>, String> {
    let reply = app.run("render.scene", json!({}))?;
    let values = reply.get("bodies").and_then(Value::as_array).ok_or_else(|| crate::i18n::tr("render.error_scene_bodies").to_string())?;
    if values.len() > solidcraft_engine::render::job::MAX_GPU_PATH_BODIES {
        return Err(crate::i18n::tr("render.error_scene_body_limit").into());
    }
    let targets: Vec<Target> = serde_json::from_value(Value::Array(values.clone())).map_err(|e| e.to_string())?;
    if targets.iter().any(|t| {
        t.ordinal >= solidcraft_engine::render::job::MAX_GPU_PATH_BODIES
            || t.name.is_empty()
            || t.name.len() > 1024
            || t.name.chars().any(char::is_control)
    }) {
        return Err(crate::i18n::tr("render.error_scene_identity").into());
    }
    Ok(targets)
}

pub(super) fn revalidate(app: &mut SolveApp, binding: &mut Binding) -> Result<(), String> {
    let targets = read_targets(app)?;
    if (binding.coat_enabled || binding.saved_coat_source.is_some() || binding.coat_edited)
        && let Some(stable) = &binding.target.stable_target
    {
        let mut matches = targets.iter().filter(|target| target.stable_target.as_ref() == Some(stable));
        let target = matches.next().cloned().ok_or_else(|| app.tr("render.material_target_missing").to_string())?;
        if matches.next().is_some() {
            return Err(app.tr("render.material_target_missing").into());
        }
        binding.target = target;
    } else if !targets.contains(&binding.target) {
        return Err(app.tr("render.material_target_missing").to_string());
    }
    binding.revision = app.session.revision;
    binding.document = Arc::downgrade(&app.session.doc);
    Ok(())
}

/// Render settings may change document identity without changing the reviewed source.
/// A changed model, material, placement or target still needs explicit revalidation.
pub(super) fn refresh_render_revision(app: &mut SolveApp) {
    if app.render_workspace.view.materials.bindings.is_empty() {
        return;
    }
    let Ok(targets) = read_targets(app) else { return };
    let mut sources = super::setups::SourceCache::default();
    let eligible: Vec<bool> = app
        .render_workspace
        .view
        .materials
        .bindings
        .iter()
        .map(|binding| sources.same_model_source(app, &binding.document) && targets.contains(&binding.target))
        .collect();
    let saved = app.session.doc.render.setups.get(&app.render_workspace.view.name).map(|setup| &setup.coats);
    for (binding, eligible) in app.render_workspace.view.materials.bindings.iter_mut().zip(eligible) {
        if eligible {
            binding.revision = app.session.revision;
            binding.document = Arc::downgrade(&app.session.doc);
            // Stable source identity was proved above. Only unedited coat fields
            // may follow saved Undo/Redo/replacement; independent map drafts stay.
            if !binding.coat_has_local_changes() && !binding.glass_enabled {
                let current =
                    saved.and_then(|rows| rows.iter().find(|row| binding.target.stable_target.as_ref() == Some(&row.target))).map(|row| row.coat);
                if let Some(coat) = current {
                    binding.hydrate_coat(coat);
                } else if binding.saved_coat_source.is_some() {
                    binding.saved_coat_source = None;
                    binding.coat_enabled = false;
                }
            }
        }
    }
}

/// Overlay stable Glass drafts into a captured request only. Explicit binding
/// remains the sole save action; ordinal inputs never replace these rows.
pub(super) fn overlay_saved(app: &SolveApp, setup: &mut solidcraft_engine::doc::render_settings::RenderSetup) -> Result<(), String> {
    overlay_coats(app, setup)?;
    overlay_optics(app, setup)
}

fn overlay_optics(app: &SolveApp, setup: &mut solidcraft_engine::doc::render_settings::RenderSetup) -> Result<(), String> {
    let view = &app.render_workspace.view.materials;
    for binding in
        view.bindings.iter().filter(|binding| binding.stable_optics() && binding.active() && (view.enabled || binding.saved_source.is_some()))
    {
        if !binding.current(app) {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        let target = binding.target.stable_target.as_ref().ok_or_else(|| app.tr("render.material_target_missing").to_string())?;
        let baseline = app.render_workspace.view.draft.optics.iter().find(|saved| &saved.target == target).map(|saved| saved.optics);
        if baseline != binding.saved_source {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        let source = setup.optics.iter().find(|saved| &saved.target == target).map(|saved| saved.optics);
        let prospective = (binding.enabled && binding.glass_enabled).then(|| binding.optics());
        // An already-overlaid request is idempotent. A row in the actual draft
        // still needs its exact saved-source proof, even if its values coincide.
        if source != baseline && source != prospective {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        if binding.coat_enabled || binding.maps_enabled {
            return Err(app.tr("render.material_saved_edit_pending").into());
        }
        if !binding.enabled || !binding.glass_enabled {
            setup.optics.remove(target);
        } else {
            setup
                .optics
                .set(
                    solidcraft_engine::doc::render_optics::SavedOptics { target: target.clone(), optics: binding.optics() },
                    binding.saved_source.is_some(),
                )
                .map_err(|error| error.to_string())?;
        }
    }
    Ok(())
}

/// Stable coat edits use the same captured settings for CPU and GPU. This is a
/// pure overlay; generic Save still requires the explicit coat binding action.
pub(super) fn overlay_coats(app: &SolveApp, setup: &mut solidcraft_engine::doc::render_settings::RenderSetup) -> Result<(), String> {
    if !app.render_workspace.view.materials.enabled {
        return Ok(());
    }
    for binding in &app.render_workspace.view.materials.bindings {
        if !binding.coat_enabled && binding.saved_coat_source.is_none() && !binding.coat_edited {
            continue;
        }
        if !binding.current(app) {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        let target = binding.target.stable_target.as_ref().ok_or_else(|| app.tr("render.material_target_missing").to_string())?;
        if let Some(expected) = binding.saved_coat_source {
            let current = setup.coats.iter().find(|saved| &saved.target == target).map(|saved| saved.coat);
            if current != Some(expected) {
                return Err(app.tr("render.material_revalidate_needed").into());
            }
        } else if setup.coats.iter().any(|saved| &saved.target == target) {
            return Err(app.tr("render.coat_revalidate_saved").into());
        }
        if binding.glass_enabled && binding.coat_enabled {
            return Err(app.tr("render.material_glass_exclusive").into());
        }
        if !binding.enabled || !binding.coat_enabled {
            if binding.saved_coat_source.is_some() {
                setup.coats.remove(target);
            }
        } else {
            setup
                .coats
                .set(solidcraft_engine::doc::render_coat::SavedCoat { target: target.clone(), coat: binding.coat_material() }, true)
                .map_err(|error| error.to_string())?;
        }
    }
    Ok(())
}

/// Pure prospective compatibility: no request, resources, host or document mutation.
pub(super) fn path_compatibility(app: &SolveApp) -> Result<(), String> {
    // This is the same pure stable-target overlay used by image/live capture.
    // A user's explicit unsaved removal of an unsupported flag must already be
    // reflected by the availability of the transport it makes compatible.
    let mut prospective = solidcraft_engine::doc::render_settings::RenderSetup {
        optics: app.render_workspace.view.draft.optics.clone(),
        coats: app.render_workspace.view.draft.coats.clone(),
        ..Default::default()
    };
    overlay_saved(app, &mut prospective)?;
    prospective.optics.validate_for_cpu_path(true).map_err(|e| e.to_string())?;
    if app.render_workspace.view.studio.denoise && prospective.optics.iter().any(|b| b.optics.subsurface.is_some_and(|s| s.active())) {
        return Err(app.tr("render.cpu_subsurface_denoise_reason").into());
    }
    for binding in app.render_workspace.view.materials.bindings.iter().filter(|b| b.saved_source.is_none() && b.active() && b.glass_enabled) {
        if !binding.current(app) {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        binding.optics().validate_for_cpu_path(true).map_err(|e| e.to_string())?;
        if app.render_workspace.view.studio.denoise && binding.glass.subsurface.is_some_and(|s| s.active()) {
            return Err(app.tr("render.cpu_subsurface_denoise_reason").into());
        }
    }
    Ok(())
}
/// Called for every Check and Start through the one shared image request builder.
/// No files are read until the engine captures the actual request.
pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> {
    let view = &app.render_workspace.view.materials;
    // A file HDR can select this lane even when every Glass row is stable.
    // Preserve those rows in settings, not a second ordinal representation.
    if view.bindings.iter().any(|binding| binding.stable_optics() && binding.active() && (view.enabled || binding.saved_source.is_some())) {
        let mut settings = serde_json::from_value(params["settings"].clone()).map_err(|error| error.to_string())?;
        overlay_optics(app, &mut settings)?;
        params["settings"] = json!(settings);
    }
    if !view.enabled || !view.bindings.iter().any(|binding| binding.active() && !binding.stable_optics()) {
        return Ok(());
    }
    let cpu = app.render_workspace.view.method == super::ImageMethod::CpuRaytrace;
    if app.render_workspace.view.method == super::ImageMethod::Raster {
        return Err(app.tr("render.material_raytrace_required").to_string());
    }
    if cpu && !app.render_workspace.view.draft.optics.is_empty() {
        return Err(app.tr("render.material_cpu_saved_runtime_conflict").into());
    }
    if view.bindings.len() > MAX_BINDINGS {
        return Err(app.tr("render.material_limits").to_string());
    }
    let (mut glass, mut textures) = (Vec::new(), Vec::new());
    let mut seen = std::collections::BTreeSet::new();
    for binding in view.bindings.iter().filter(|b| b.active() && !b.stable_optics()) {
        if !binding.current(app) {
            return Err(app.tr("render.material_revalidate_needed").to_string());
        }
        if binding.saved_source.is_some() {
            return Err(app.tr("render.material_saved_edit_pending").into());
        }
        let target = &binding.target;
        if target.ordinal >= solidcraft_engine::render::job::MAX_GPU_PATH_BODIES
            || target.name.is_empty()
            || target.name.len() > 1024
            || target.name.chars().any(char::is_control)
            || !seen.insert(target.ordinal)
        {
            return Err(app.tr("render.material_target_missing").to_string());
        }
        if binding.glass_enabled && (binding.coat_enabled || binding.maps_enabled) {
            return Err(app.tr("render.material_glass_exclusive").to_string());
        }
        if cpu && binding.maps_enabled {
            return Err(app.tr("render.material_cpu_glass_only").into());
        }
        let identity = || json!({"body_index":target.ordinal,"body_name":target.name});
        if cpu && binding.glass_enabled {
            let optical = binding.optics();
            glass.push(json!(
                optical
                    .to_cpu_for_path(target.ordinal, &target.name, app.render_workspace.view.raytrace.path.is_some())
                    .map_err(|error| error.to_string())?
            ));
        } else if binding.glass_enabled {
            let value = &binding.glass;
            OpaqueSurface::new(Vec3::ZERO, 0.0, 0.5, value.ior).map_err(|e| e.to_string())?;
            let [r, g, b] = value.absorption;
            Transmission::new(Vec3::new(r, g, b), (value.boundary == Boundary::Thin).then_some(value.thickness)).map_err(|e| e.to_string())?;
            let mut wire = identity();
            wire["ior"] = json!(value.ior);
            wire["absorption_per_mm"] = json!(value.absorption);
            wire["boundary"] = json!(value.boundary.wire());
            wire["thickness_mm"] = json!(if value.boundary == Boundary::Thin { value.thickness } else { 0.0 });
            wire["shadow_transmission"] = json!(value.shadows);
            if let Some(model) = value.model {
                model.validate(value.ior).map_err(|e| e.to_string())?;
                wire["model"] = json!(model);
            }
            if let Some(subsurface) = value.subsurface {
                Transmission::new(Vec3::new(r, g, b), (value.boundary == Boundary::Thin).then_some(value.thickness))
                    .map_err(|e| e.to_string())?
                    .with_shadow_transmission(value.shadows)
                    .with_subsurface(subsurface)
                    .map_err(|e| e.to_string())?;
                wire["subsurface"] = json!(subsurface);
            }
            glass.push(wire);
        }
        if binding.coat_enabled {
            let value = &binding.coat;
            ClearCoat::new(value.weight, value.roughness, value.ior).map_err(|e| e.to_string())?;
            // The stable coat overlay already captured these exact numbers.
            // Never duplicate it as an ordinal runtime override.
        }
        if binding.maps_enabled {
            let value = &binding.maps;
            value.frame.validate().map_err(|e| e.to_string())?;
            if value.color.is_empty() && value.normal.is_empty() && value.roughness.is_empty() && value.metallic.is_empty() {
                return Err(app.tr("render.material_map_required").to_string());
            }
            if !value.strength.is_finite()
                || !(0.0..=1.0).contains(&value.strength)
                || [&value.color, &value.normal, &value.roughness, &value.metallic].iter().any(|p| p.len() > 4096 || p.chars().any(char::is_control))
            {
                return Err(app.tr("render.material_map_invalid").to_string());
            }
            let mut wire = identity();
            wire["frame"] = json!(value.frame);
            wire["normal_strength"] = json!(value.strength);
            wire["base_color_mode"] = json!(value.base_color_mode);
            wire["flip_v"] = json!(value.flip_v);
            if !value.color.is_empty() {
                wire["base_color_srgb"] = json!(value.color);
            }
            if !value.normal.is_empty() {
                wire["normal_opengl"] = json!(value.normal);
            }
            if !value.roughness.is_empty() {
                wire["roughness_linear"] = json!(value.roughness);
            }
            if !value.metallic.is_empty() {
                wire["metallic_linear"] = json!(value.metallic);
            }
            textures.push(wire);
        }
    }
    if glass.len() > solidcraft_engine::render::job::MAX_GPU_DIELECTRICS
        || textures.len() > solidcraft_engine::render::job::textures::MAX_TEXTURE_BINDINGS
    {
        return Err(app.tr("render.material_limits").to_string());
    }
    if cpu {
        // Preserve all CPU lights, output, lens and sampling. This is the same
        // numerical override type produced by stable saved-optics lowering.
        params["raytrace"]["dielectrics"] = json!(glass);
        let options: solidcraft_engine::render::job::RaytraceOptions =
            serde_json::from_value(params["raytrace"].clone()).map_err(|error| error.to_string())?;
        options.validate().map_err(|error| error.to_string())?;
    } else {
        params["raytrace"] = json!({"dielectrics":glass,"textures":textures});
    }
    Ok(())
}

fn vector(app: &SolveApp, ui: &mut egui::Ui, key: &str, values: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, suffix: &str) -> bool {
    ui_kit::row(ui, app.tr(key), |ui| ui_kit::vector3_field(ui, values, range, suffix))
}

#[cfg(test)]
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
    let title = app.tr("render.material_title").to_string();
    ui_kit::section(ui, "render_materials", &title, false, |ui| {
        let mut view = std::mem::take(&mut app.render_workspace.view.materials);
        ui.small(app.tr("render.material_transient"));
        ui_kit::checkbox(ui, app.tr("render.material_enable"), &mut view.enabled);
        if app.render_workspace.view.method != super::ImageMethod::GpuRaytrace && view.enabled && view.bindings.iter().any(Binding::active) {
            ui.colored_label(Tokens::get().warning, app.tr("render.material_gpu_required"));
        }
        if ui_kit::button(ui, app.tr("render.material_refresh"), ui_kit::Button::Normal).clicked() {
            match read_targets(app) {
                Ok(targets) => {
                    view.targets = targets;
                    view.target = None;
                    view.target_revision = Some(app.session.revision);
                    view.target_document = Some(Arc::downgrade(&app.session.doc));
                }
                Err(e) => app.set_status(e, true),
            }
        }
        let current = view.target_revision == Some(app.session.revision)
            && view.target_document.as_ref().is_some_and(|doc| Weak::ptr_eq(doc, &Arc::downgrade(&app.session.doc)))
            && !app.session.model.is_stale();
        ui_kit::bounded_cell_editor(
            ui,
            ui.scope_id().with("render_material_search"),
            &mut view.target_search,
            app.tr("render.material_filter"),
            false,
            128,
        );
        let query = view.target_search.trim().to_lowercase();
        let label =
            view.target.and_then(|i| view.targets.get(i)).map_or_else(|| app.tr("render.material_choose_body").to_string(), |t| t.name.clone());
        ui_kit::dropdown_menu(ui, "render_material_target", &label, |ui| {
            for (index, target) in view.targets.iter().enumerate().filter(|(_, t)| t.name.to_lowercase().contains(&query)).take(128) {
                if ui_kit::list_picker(ui, &format!("render:material-body-{}", target.ordinal), &target.name, view.target == Some(index)).clicked() {
                    view.target = Some(index);
                    ui.close();
                }
            }
        });
        let target = view.target.and_then(|index| view.targets.get(index));
        let existing = target.and_then(|target| view.bindings.iter().position(|binding| binding.target == *target));
        if ui_kit::button(
            ui,
            app.tr("render.material_add"),
            ui_kit::Button::Enabled(current && target.is_some() && (existing.is_some() || view.bindings.len() < MAX_BINDINGS)),
        )
        .clicked()
            && let Some(target) = target.cloned()
        {
            view.selected = if let Some(index) = existing {
                Some(index)
            } else {
                view.bindings.push(Binding::new(target, app));
                Some(view.bindings.len() - 1)
            };
            view.enabled = true;
        }
        if view.targets.len() > 128 {
            ui.small(app.tr("render.material_filter_help"));
        }
        if !current && !view.targets.is_empty() {
            ui.small(app.tr("render.material_refresh_needed"));
        }
        let selected = view
            .selected
            .and_then(|i| view.bindings.get(i))
            .map_or_else(|| app.tr("render.material_assignments").to_string(), |b| b.target.name.clone());
        ui_kit::dropdown_menu(ui, "render_material_binding", &selected, |ui| {
            for (index, binding) in view.bindings.iter().enumerate() {
                if ui_kit::list_picker(ui, &format!("render:material-binding-{index}"), &binding.target.name, view.selected == Some(index)).clicked()
                {
                    view.selected = Some(index);
                    ui.close();
                }
            }
        });
        let mut remove = false;
        if let Some(binding) = view.selected.and_then(|index| view.bindings.get_mut(index)) {
            ui.small(format!("{} · #{}", binding.target.name, binding.target.ordinal));
            ui_kit::checkbox(ui, app.tr("render.material_binding_enable"), &mut binding.enabled);
            if !binding.current(app) {
                ui.colored_label(Tokens::get().warning, app.tr("render.material_revalidate_needed"));
                if ui_kit::button(ui, app.tr("render.material_revalidate"), ui_kit::Button::Normal).clicked()
                    && let Err(e) = revalidate(app, binding)
                {
                    app.set_status(e, true);
                }
            }
            remove |= editor_sections(app, ui, Some(binding));
            remove |= ui_kit::button(ui, app.tr("render.material_remove"), ui_kit::Button::Normal).clicked();
        }
        if remove && let Some(index) = view.selected.filter(|i| *i < view.bindings.len()) {
            view.bindings.remove(index);
            view.selected = None;
        }
        ui.small(app.tr("render.material_limits"));
        view.pending_remove = app.render_workspace.view.materials.pending_remove.take().or(view.pending_remove.take());
        app.render_workspace.view.materials = view;
    });
}

fn glass_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) {
    let cpu = app.render_workspace.view.method == super::ImageMethod::CpuRaytrace;
    let path = app.render_workspace.view.raytrace.path.is_some();
    let enabled = ui_kit::checkbox(ui, app.tr("render.appearance_editor.glass_enable"), &mut binding.glass_enabled);
    crate::scenario::publish_target("render:glass:enable", enabled.rect);
    if enabled.changed() && binding.glass_enabled {
        binding.coat_enabled = false;
        binding.maps_enabled = false;
    }
    let recipes: Vec<_> = appearance_pack::STARTER_PACK.iter().filter(|p| matches!(p.recipe, Recipe::Glass(_))).collect();
    let name =
        binding.glass.recipe.and_then(appearance_pack::find).map_or_else(|| app.tr("render.material_custom").to_owned(), |p| p.name.to_owned());
    let recipe_label = app.tr("render.appearance_editor.recipe").to_owned();
    ui_kit::row(ui, &recipe_label, |ui| {
        ui_kit::dropdown_menu(ui, "render_glass_recipe", &name, |ui| {
            for preset in recipes {
                let response = ui_kit::list_picker(ui, preset.id, preset.name, binding.glass.recipe == Some(preset.id));
                crate::scenario::publish_target(&format!("render:glass:{}", preset.id), response.rect);
                if response.clicked() {
                    match Glass::recipe(preset.id) {
                        Ok(glass) => {
                            binding.glass = glass;
                            binding.glass_enabled = true;
                            binding.coat_enabled = false;
                            binding.maps_enabled = false;
                        }
                        Err(error) => app.set_status(error, true),
                    }
                    ui.close();
                }
            }
        });
    });
    let glass = &mut binding.glass;
    let mut changed = false;
    ui.add_enabled_ui(binding.glass_enabled, |ui| {
        changed |= advanced_glass_controls(app, ui, glass);
        let mut boundary = match glass.boundary {
            Boundary::Closed => 0,
            Boundary::Thin => 1,
            Boundary::Box => 2,
        };
        ui_kit::row(ui, app.tr("render.appearance_editor.boundary"), |ui| {
            let labels = ["render.appearance_editor.closed", "render.appearance_editor.thin", "render.appearance_editor.box"].map(|key| app.tr(key));
            if ui_kit::segmented(ui, &mut boundary, &labels, ui_kit::Segments { compact: true, small: true, ..Default::default() }) {
                glass.boundary = match boundary {
                    1 => Boundary::Thin,
                    2 => Boundary::Box,
                    _ => Boundary::Closed,
                };
                if !cpu {
                    glass.shadows = glass.boundary == Boundary::Thin;
                }
                changed = true;
            }
        });
        changed |= ui_kit::row(ui, app.tr("render.appearance_editor.ior"), |ui| {
            let response = ui_kit::number_field(ui, &mut glass.ior, 1.0..=3.0, 0.01, "");
            crate::scenario::publish_target("render:glass:ior-field", response.rect);
            response
        })
        .changed();
        ui.add_enabled_ui(glass.boundary == Boundary::Thin, |ui| {
            changed |= ui_kit::row(ui, app.tr("render.appearance_editor.thickness"), |ui| {
                let response = ui_kit::number_field_preserving(ui, &mut glass.thickness, 0.0..=10000.0, 0.1, " mm");
                crate::scenario::publish_target("render:glass:thickness-field", response.rect);
                response
            })
            .changed();
        });
        let absorption = app.tr("render.appearance_editor.absorption").to_owned();
        // Each suffixed DragValue needs the full control column. Three cells
        // can expand a narrow inspector despite their individual clip rects.
        for ((axis, value), channel) in glass.absorption.iter_mut().enumerate().zip(["R", "G", "B"]) {
            changed |= ui_kit::row(ui, &format!("{absorption} {channel}"), |ui| {
                let field = ui_kit::number_field(ui, value, 0.0..=100.0, 0.01, " /mm");
                crate::scenario::publish_target(&format!("dialog:vector:{absorption}:{axis}"), field.rect);
                field
            })
            .changed();
        }
        ui.add_enabled_ui(!cpu || (path && glass.boundary == Boundary::Thin) || glass.shadows, |ui| {
            changed |= ui_kit::checkbox(ui, app.tr("render.material_shadow"), &mut glass.shadows).changed();
        });
        // Existing unsupported choices remain removable. Positive CPU scattering
        // requires the explicit closed-medium Path, never silent adoption.
        ui.add_enabled_ui((glass.boundary != Boundary::Thin && (!cpu || path)) || glass.subsurface.is_some(), |ui| {
            let mut scatter = glass.subsurface.is_some();
            let toggle = ui_kit::checkbox(ui, app.tr("render.subsurface_enable"), &mut scatter);
            crate::scenario::publish_target("render:glass:subsurface-enable", toggle.rect);
            if toggle.changed() {
                glass.subsurface =
                    scatter.then_some(solidcraft_engine::render::transmission::subsurface::Subsurface { scattering_per_mm: 0.1, anisotropy: 0.0 });
                changed = true;
            }
            if let Some(subsurface) = &mut glass.subsurface {
                ui.add_enabled_ui(!cpu || (path && glass.boundary != Boundary::Thin), |ui| {
                    changed |= ui_kit::row(ui, app.tr("render.subsurface_rate"), |ui| {
                        let field = ui_kit::number_field_preserving(ui, &mut subsurface.scattering_per_mm, 0.0..=100.0, 0.001, " /mm");
                        crate::scenario::publish_target("render:glass:subsurface-rate", field.rect);
                        field
                    })
                    .changed();
                    changed |= ui_kit::row(ui, app.tr("render.volume_anisotropy"), |ui| {
                        let field = ui_kit::number_field_preserving(ui, &mut subsurface.anisotropy, -0.95..=0.95, 0.01, "");
                        crate::scenario::publish_target("render:glass:subsurface-g", field.rect);
                        field
                    })
                    .changed();
                });
            }
        });
        if cpu {
            note(app, ui, "render.cpu_subsurface_help");
        }
        if glass.boundary != Boundary::Thin {
            note(app, ui, "render.appearance_editor.thickness_reason");
        }
        if glass.boundary == Boundary::Thin {
            note(app, ui, "render.appearance_editor.scatter_reason");
        }
    });
    if changed {
        glass.recipe = None;
    }
    note(app, ui, "render.appearance_editor.glass_note");
    note(app, ui, if cpu { "render.cpu_material_certification" } else { "render.material_certification" });
}

fn advanced_glass_controls(app: &SolveApp, ui: &mut egui::Ui, glass: &mut Glass) -> bool {
    use solidcraft_engine::render::glass_model::{Dispersion, GlassModel, ThinFilm};
    let before = glass.model;
    let mut enabled = before.is_some();
    let toggle = ui_kit::checkbox(ui, app.tr("render.glass_model_enable"), &mut enabled);
    crate::scenario::publish_target("render:glass:model-enable", toggle.rect);
    if toggle.changed() {
        glass.model = enabled.then(GlassModel::default);
    }
    if let Some(model) = &mut glass.model {
        ui_kit::row(ui, app.tr("render.glass_roughness"), |ui| {
            let field = ui_kit::number_field_preserving(ui, &mut model.roughness, 0.0..=1.0, 0.01, "");
            crate::scenario::publish_target("render:glass:roughness", field.rect);
            field
        });
        let mut dispersion = model.dispersion.is_some();
        let toggle = ui_kit::checkbox(ui, app.tr("render.glass_dispersion"), &mut dispersion);
        crate::scenario::publish_target("render:glass:dispersion-enable", toggle.rect);
        if toggle.changed() {
            model.dispersion = dispersion.then_some(Dispersion { abbe_number: 50.0 });
        }
        if let Some(dispersion) = &mut model.dispersion {
            ui_kit::row(ui, app.tr("render.glass_abbe"), |ui| {
                let field = ui_kit::number_field_preserving(ui, &mut dispersion.abbe_number, 5.0..=200.0, 0.5, "");
                crate::scenario::publish_target("render:glass:abbe", field.rect);
                field
            });
        }
        let mut film = model.thin_film.is_some();
        let toggle = ui_kit::checkbox(ui, app.tr("render.glass_film"), &mut film);
        crate::scenario::publish_target("render:glass:film-enable", toggle.rect);
        if toggle.changed() {
            model.thin_film = film.then_some(ThinFilm { ior: 1.35, thickness_nm: 400.0 });
        }
        if let Some(film) = &mut model.thin_film {
            ui_kit::row(ui, app.tr("render.glass_film_ior"), |ui| {
                let field = ui_kit::number_field_preserving(ui, &mut film.ior, 1.0..=3.0, 0.01, "");
                crate::scenario::publish_target("render:glass:film-ior", field.rect);
                field
            });
            ui_kit::row(ui, app.tr("render.glass_film_thickness"), |ui| {
                let field = ui_kit::number_field_preserving(ui, &mut film.thickness_nm, 0.0..=100000.0, 1.0, " nm");
                crate::scenario::publish_target("render:glass:film-thickness", field.rect);
                field
            });
        }
        ui_kit::text(ui, app.tr("render.glass_model_help"), ui_kit::Text::Note("render.glass_model_help"));
    }
    before != glass.model
}

fn coat_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) -> bool {
    let enabled = ui_kit::checkbox(ui, app.tr("render.material_coat_enable"), &mut binding.coat_enabled);
    crate::scenario::publish_target("render:coat:enable", enabled.rect);
    let mut changed = enabled.changed();
    ui.add_enabled_ui(binding.coat_enabled, |ui| {
        for (key, value, range) in [
            ("render.appearance_editor.weight", &mut binding.coat.weight, 0.0..=1.0),
            ("appearance.roughness", &mut binding.coat.roughness, 0.045..=1.0),
        ] {
            changed |= ui_kit::row(ui, app.tr(key), |ui| {
                let response = ui_kit::mixed_slider(ui, value, range, None);
                crate::scenario::publish_target(
                    if key == "render.appearance_editor.weight" { "render:coat:weight" } else { "render:coat:roughness" },
                    response.rect,
                );
                response
            })
            .changed();
        }
        changed |= ui_kit::row(ui, app.tr("render.appearance_editor.ior"), |ui| {
            let response = ui_kit::number_field_preserving(ui, &mut binding.coat.ior, 1.0..=3.0, 0.01, "");
            crate::scenario::publish_target("render:coat:ior-field", response.rect);
            response
        })
        .changed();
    });
    binding.coat_edited |= changed;
    saved_coat_controls(app, ui, binding)
}

#[derive(Clone, Copy)]
enum MapSlot {
    Color,
    Normal,
    Roughness,
    Metallic,
}
impl MapSlot {
    fn key(self) -> &'static str {
        match self {
            Self::Color => "render.appearance_editor.base_colour",
            Self::Normal => "render.appearance_editor.normal",
            Self::Roughness => "appearance.roughness",
            Self::Metallic => "appearance.metallic",
        }
    }
    fn field(self, maps: &mut Maps) -> &mut String {
        match self {
            Self::Color => &mut maps.color,
            Self::Normal => &mut maps.normal,
            Self::Roughness => &mut maps.roughness,
            Self::Metallic => &mut maps.metallic,
        }
    }
}
fn choose_map(app: &mut SolveApp, binding: &Binding, slot: MapSlot) {
    let target = binding.target.clone();
    let origin = binding.document.clone();
    let revision = binding.revision;
    app.pick_open_for(&["png", "jpg", "jpeg"], move |app, path| {
        if !Weak::ptr_eq(&origin, &Arc::downgrade(&app.session.doc)) || app.session.revision != revision {
            return;
        }
        if let Some(path) = path
            && let Some(binding) = app
                .render_workspace
                .view
                .materials
                .bindings
                .iter_mut()
                .find(|b| b.target == target && b.revision == revision && Weak::ptr_eq(&b.document, &origin))
        {
            *slot.field(&mut binding.maps) = path;
        }
    });
}

/// Prepare through the engine, then install only a request-local binding. No
/// authored material may silently remove a glass override or switch executor.
pub(super) fn install_library_surface(
    app: &mut SolveApp,
    id: &str,
    target: Target,
    plane: &str,
    scale: f64,
    rotation_rad: f64,
) -> Result<(), String> {
    if app.render_workspace.view.method != super::ImageMethod::GpuRaytrace {
        return Err(app.tr("render.material_gpu_required").into());
    }
    let existing = app.render_workspace.view.materials.bindings.iter().position(|b| b.target == target);
    if let Some(index) = existing {
        let binding =
            app.render_workspace.view.materials.bindings.get(index).ok_or_else(|| crate::i18n::tr("render.error_material_binding").to_string())?;
        if !binding.current(app) {
            return Err(app.tr("render.material_revalidate_needed").into());
        }
        if binding.glass_enabled {
            return Err(app.tr("render.material_glass_exclusive").into());
        }
    } else if app.render_workspace.view.materials.bindings.len() >= MAX_BINDINGS {
        return Err(app.tr("render.material_limits").into());
    }
    let reply = app.run(
        "render.library.surface.prepare",
        json!({"id":id,"body_index":target.ordinal,"body_name":target.name,"plane":plane,"scale":scale,"rotation_rad":rotation_rad}),
    )?;
    let texture = &reply["texture"];
    let frame: PlanarFrame = serde_json::from_value(texture["frame"].clone()).map_err(|e| e.to_string())?;
    let path = |key: &str| texture[key].as_str().map(str::to_string).ok_or_else(|| crate::i18n::tr("render.error_surface_reply").to_string());
    let maps = Maps {
        color: path("base_color_srgb")?,
        normal: path("normal_opengl")?,
        roughness: path("roughness_linear")?,
        metallic: path("metallic_linear")?,
        strength: 1.0,
        frame,
        base_color_mode: BaseColorMode::Replace,
        flip_v: true,
    };
    let mut binding = if let Some(index) = existing {
        app.render_workspace
            .view
            .materials
            .bindings
            .get(index)
            .cloned()
            .ok_or_else(|| crate::i18n::tr("render.error_material_binding").to_string())?
    } else {
        Binding::new(target, app)
    };
    if binding.saved_coat_source.is_none()
        && !binding.coat_has_local_changes()
        && let Some(saved) = app.render_workspace.view.draft.coats.iter().find(|saved| binding.target.stable_target.as_ref() == Some(&saved.target))
    {
        binding.hydrate_coat(saved.coat);
    }
    binding.maps = maps;
    binding.maps_enabled = true;
    binding.enabled = true;
    let view = &mut app.render_workspace.view.materials;
    if let Some(index) = existing {
        *view.bindings.get_mut(index).ok_or_else(|| crate::i18n::tr("render.error_material_binding").to_string())? = binding;
        view.selected = Some(index);
    } else {
        view.bindings.try_reserve(1).map_err(|_| crate::i18n::tr("render.error_binding_allocation").to_string())?;
        view.bindings.push(binding);
        view.selected = Some(view.bindings.len() - 1);
    }
    view.enabled = true;
    app.render_workspace.view.dirty = true;
    Ok(())
}

fn map_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) {
    ui_kit::checkbox(ui, app.tr("render.material_maps_enable"), &mut binding.maps_enabled);
    ui.add_enabled_ui(binding.maps_enabled, |ui| {
        for slot in [MapSlot::Color, MapSlot::Normal, MapSlot::Metallic, MapSlot::Roughness] {
            let label = app.tr(slot.key()).to_owned();
            ui_kit::row(ui, &label, |ui| {
                let path = slot.field(&mut binding.maps);
                let label = if path.is_empty() {
                    app.tr("render.appearance_editor.choose_image").to_owned()
                } else {
                    std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default()
                };
                if ui_kit::button(ui, &label, ui_kit::Button::Enabled(binding.current(app))).clicked() {
                    choose_map(app, binding, slot);
                }
            });
        }
        vector(app, ui, "render.appearance_editor.origin", &mut binding.maps.frame.origin, -1e9..=1e9, " mm");
        vector(app, ui, "render.appearance_editor.u_repeat", &mut binding.maps.frame.u, -1e6..=1e6, " mm");
        vector(app, ui, "render.appearance_editor.v_repeat", &mut binding.maps.frame.v, -1e6..=1e6, " mm");
        ui_kit::row(ui, app.tr("render.appearance_editor.normal_strength"), |ui| {
            ui_kit::mixed_slider(ui, &mut binding.maps.strength, 0.0..=1.0, None)
        });
        ui_kit::checkbox(ui, app.tr("render.appearance_editor.v_up"), &mut binding.maps.flip_v);
        let mut absolute = binding.maps.base_color_mode == BaseColorMode::Replace;
        if ui_kit::checkbox(ui, app.tr("render.material_color_replace"), &mut absolute).changed() {
            binding.maps.base_color_mode = if absolute { BaseColorMode::Replace } else { BaseColorMode::Modulate };
        }
    });
}

fn save_coat(app: &mut SolveApp, binding: &Binding) -> Result<(), String> {
    if !binding.current(app) {
        return Err(app.tr("render.material_revalidate_needed").into());
    }
    let saved = app
        .session
        .doc
        .render
        .setups
        .get(&app.render_workspace.view.name)
        .and_then(|setup| setup.coats.iter().find(|saved| binding.target.stable_target.as_ref() == Some(&saved.target)))
        .map(|saved| saved.coat);
    if saved != binding.saved_coat_source {
        return Err(app.tr("render.coat_revalidate_saved").into());
    }
    let mut local = std::mem::take(&mut app.render_workspace.view.materials);
    let preserve_maps = binding.has_local_map_intent();
    if preserve_maps && !local.bindings.iter().any(|old| old.target == binding.target) {
        if local.bindings.len() >= MAX_BINDINGS {
            app.render_workspace.view.materials = local;
            return Err(app.tr("render.material_limits").into());
        }
        let count = local.bindings.len() + 1;
        let mut reserved = Vec::new();
        if reserved.try_reserve_exact(count).is_err() || reserved.capacity() != count {
            app.render_workspace.view.materials = local;
            return Err(app.tr("render.error_binding_allocation").into());
        }
        reserved.append(&mut local.bindings);
        local.bindings = reserved;
    }
    let setup = super::setups::snapshot(app);
    app.render_workspace.view.materials = local;
    let mut setup = setup?;
    let name = app.render_workspace.view.name.clone();
    if let Some(saved) = app.session.doc.render.setups.get(&name) {
        setup.camera = saved.camera;
    }
    app.run(
        "render.coat.bind",
        json!({"name":name,"set":setup,"body_index":binding.target.ordinal,"body_name":binding.target.name,
        "coat":binding.coat_material(),"replace":binding.replace_saved_optics,"expected_revision":app.session.revision}),
    )?;
    let mut local = std::mem::take(&mut app.render_workspace.view.materials);
    super::setups::load(app);
    if preserve_maps {
        let mut retained = binding.clone();
        retained.saved_coat_source = Some(binding.coat_material());
        retained.coat_edited = false;
        retained.revision = app.session.revision;
        retained.document = Arc::downgrade(&app.session.doc);
        if let Some(old) = local.bindings.iter_mut().find(|old| old.target == binding.target) {
            *old = retained;
        } else {
            // This exact slot was fallibly reserved before the document command.
            local.bindings.push(retained);
        }
    }
    app.render_workspace.view.materials = local;
    Ok(())
}

fn saved_coat_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) -> bool {
    let saved =
        binding.target.stable_target.as_ref().and_then(|target| app.render_workspace.view.draft.coats.iter().find(|saved| &saved.target == target));
    let target = saved.map(|saved| saved.target.clone());
    note(app, ui, "render.coat_saved_help");
    if !binding.current(app) {
        note(app, ui, "render.material_revalidate_needed");
        let response = ui_kit::button(ui, app.tr("render.appearance_editor.revalidate"), ui_kit::Button::Normal);
        crate::scenario::publish_target("render:coat:revalidate", response.rect);
        if response.clicked()
            && let Err(error) = revalidate(app, binding)
        {
            app.set_status(error, true);
        }
    }
    let can_save = binding.enabled
        && binding.coat_enabled
        && !binding.glass_enabled
        && binding.current(app)
        && binding.target.stable_target.is_some()
        && (target.is_some() || app.render_workspace.view.draft.coats.len() < solidcraft_engine::doc::render_coat::MAX_COAT_BINDINGS)
        && matches!(app.render_workspace.view.method, super::ImageMethod::CpuRaytrace | super::ImageMethod::GpuRaytrace);
    let mut discard = false;
    ui.horizontal(|ui| {
        let save = ui_kit::button(ui, app.tr("render.coat_save"), ui_kit::Button::Enabled(can_save));
        crate::scenario::publish_target("render:coat:save", save.rect);
        if save.clicked() {
            match save_coat(app, binding) {
                Ok(()) => {
                    binding.saved_coat_source = Some(binding.coat_material());
                    binding.coat_edited = false;
                    binding.revision = app.session.revision;
                    binding.document = Arc::downgrade(&app.session.doc);
                    discard = !binding.has_local_map_intent();
                }
                Err(error) => app.set_status(error, true),
            }
        }
        let remove = ui_kit::button(ui, app.tr("render.coat_remove"), ui_kit::Button::Enabled(target.is_some()));
        crate::scenario::publish_target("render:coat:remove", remove.rect);
        if remove.clicked()
            && let Some(target) = target
        {
            app.render_workspace.view.materials.pending_remove = Some(PendingRemoval {
                coat: true,
                name: app.render_workspace.view.name.clone(),
                target,
                revision: app.session.revision,
                document: Arc::downgrade(&app.session.doc),
            });
        }
    });
    let replace = ui_kit::checkbox(ui, app.tr("render.appearance_editor.replace"), &mut binding.replace_saved_optics);
    crate::scenario::publish_target("render:coat:replace", replace.rect);
    if binding.coat_has_local_changes() {
        note(app, ui, "render.coat_pending_edit");
        let response = ui_kit::button(ui, app.tr("render.coat_discard"), ui_kit::Button::Normal);
        crate::scenario::publish_target("render:coat:discard", response.rect);
        if response.clicked() {
            let current = app
                .session
                .doc
                .render
                .setups
                .get(&app.render_workspace.view.name)
                .and_then(|setup| setup.coats.iter().find(|saved| binding.target.stable_target.as_ref() == Some(&saved.target)))
                .map(|saved| saved.coat);
            if let Some(saved) = current {
                binding.hydrate_coat(saved);
            } else {
                binding.saved_coat_source = None;
                binding.coat_enabled = false;
                binding.coat_edited = false;
            }
            binding.enabled = true;
            discard |= !binding.has_local_map_intent();
        }
    } else if binding.saved_coat_source.is_some() {
        note(app, ui, "render.appearance_editor.saved_state");
    }
    discard
}

fn save_optics(app: &mut SolveApp, binding: &Binding) -> Result<(), String> {
    if !binding.current(app) {
        return Err(app.tr("render.material_revalidate_needed").into());
    }
    // A saved shot owns numerical intent, not the tab's local map/coat bindings.
    // Keep those bindings intact while taking the portable shot snapshot.
    let local = std::mem::take(&mut app.render_workspace.view.materials);
    let setup = super::setups::snapshot(app);
    app.render_workspace.view.materials = local;
    let mut setup = setup?;
    let value = &binding.glass;
    let name = app.render_workspace.view.name.clone();
    if let Some(saved) = app.session.doc.render.setups.get(&name) {
        // Saving optical numbers is not the shot's explicit camera update action.
        setup.camera = saved.camera;
    }
    let optics = json!({"ior":value.ior,"absorption_per_mm":value.absorption,"boundary":value.boundary.wire(),
        "thickness_mm":if value.boundary==Boundary::Thin {value.thickness} else {0.0},"shadow_transmission":value.shadows,"subsurface":value.subsurface,"model":value.model});
    app.run(
        "render.optics.bind",
        json!({"name":name,"set":setup,"body_index":binding.target.ordinal,"body_name":binding.target.name,
        "optics":optics,"replace":binding.replace_saved_optics,"expected_revision":app.session.revision}),
    )?;
    let local = std::mem::take(&mut app.render_workspace.view.materials);
    super::setups::load(app);
    app.render_workspace.view.materials = local;
    Ok(())
}
fn note(app: &SolveApp, ui: &mut egui::Ui, key: &'static str) {
    ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
}

/// The same body editor is used by the selection inspector and explicit-target page.
/// An unsupported selection gets an inert draft so every design control is inspectable.
fn editor_sections(app: &mut SolveApp, ui: &mut egui::Ui, binding: Option<&mut Binding>) -> bool {
    let supported = binding.is_some();
    let mut placeholder = Binding::new(Target { stable_target: None, ordinal: 0, name: String::new() }, app);
    let binding = binding.unwrap_or(&mut placeholder);
    let reason = if !supported {
        Some(app.tr("render.appearance_editor.body_reason").to_owned())
    } else if app.render_workspace.view.method != super::ImageMethod::GpuRaytrace {
        Some(app.tr("render.appearance_editor.gpu_reason").to_owned())
    } else {
        None
    };
    let title = app.tr("render.appearance_editor.glass").to_owned();
    let glass_reason = if !supported {
        reason.clone()
    } else if app.render_workspace.view.method == super::ImageMethod::Raster {
        Some(app.tr("render.material_raytrace_required").to_owned())
    } else {
        None
    };
    ui_kit::method_section(ui, "render:appearance:glass", &title, "CPU / GPU", glass_reason.as_deref(), |ui| glass_controls(app, ui, binding));
    if app.render_workspace.view.method == super::ImageMethod::CpuRaytrace {
        note(app, ui, "render.material_cpu_optics_limits");
    }
    let opaque_reason = reason.clone().or_else(|| binding.glass_enabled.then(|| app.tr("render.material_glass_exclusive").to_owned()));
    let title = app.tr("render.appearance_editor.coat").to_owned();
    let coat_reason = if !supported {
        Some(app.tr("render.appearance_editor.body_reason").to_owned())
    } else if app.render_workspace.view.method == super::ImageMethod::Raster {
        Some(app.tr("render.material_raytrace_required").to_owned())
    } else {
        binding.glass_enabled.then(|| app.tr("render.material_glass_exclusive").to_owned())
    };
    let coat_removed =
        ui_kit::method_section(ui, "render:appearance:coat", &title, "CPU / GPU", coat_reason.as_deref(), |ui| coat_controls(app, ui, binding))
            .unwrap_or(false);
    let title = app.tr("render.appearance_editor.maps").to_owned();
    let map_reason = if supported && app.render_workspace.view.method == super::ImageMethod::CpuRaytrace {
        Some(app.tr("render.cpu_maps_saved_help").to_owned())
    } else {
        opaque_reason.clone()
    };
    ui_kit::method_section(ui, "render:appearance:maps", &title, "GPU", map_reason.as_deref(), |ui| map_controls(app, ui, binding));
    let title = app.tr("render.appearance_editor.saved").to_owned();
    let removed = ui_kit::editor_section(ui, "render:appearance:saved", &title, false, |ui| {
        ui.add_enabled_ui(supported, |ui| saved_controls(app, ui, binding)).inner
    })
    .unwrap_or(false);
    reflection_section(app, ui, supported.then_some(binding.target.name.as_str()));
    removed || coat_removed
}

/// Resolve one selected whole body against the authoritative captured scene. Never
/// broaden a face/component selection into a whole-body optics assignment.
pub(super) fn selection_controls(app: &mut SolveApp, ui: &mut egui::Ui, body: Option<&str>) {
    let mut binding = body.and_then(|name| app.render_workspace.view.materials.bindings.iter().find(|b| b.target.name == name).cloned());
    if binding.is_none()
        && let Some(name) = body
    {
        let current = app.render_workspace.view.materials.target_revision == Some(app.session.revision)
            && app.render_workspace.view.materials.target_document.as_ref().is_some_and(|d| Weak::ptr_eq(d, &Arc::downgrade(&app.session.doc)));
        if !current {
            match read_targets(app) {
                Ok(targets) => {
                    let view = &mut app.render_workspace.view.materials;
                    view.targets = targets;
                    view.target_revision = Some(app.session.revision);
                    view.target_document = Some(Arc::downgrade(&app.session.doc));
                }
                Err(error) => app.set_status(error, true),
            }
        }
        let mut targets = app.render_workspace.view.materials.targets.iter().filter(|t| t.name == name);
        if let Some(target) = targets.next()
            && targets.next().is_none()
        {
            let saved = app.render_workspace.view.draft.optics.iter().find(|saved| target.stable_target.as_ref() == Some(&saved.target));
            let mut hydrated =
                saved.map_or_else(|| Binding::new(target.clone(), app), |saved| Binding::from_saved(target.clone(), app, saved.optics));
            if let Some(saved) = app.render_workspace.view.draft.coats.iter().find(|saved| target.stable_target.as_ref() == Some(&saved.target)) {
                hydrated.hydrate_coat(saved.coat);
            }
            binding = Some(hydrated);
        }
    }
    let before = app.session.revision;
    let original_target = binding.as_ref().map(|binding| binding.target.clone());
    let removed = editor_sections(app, ui, binding.as_mut());
    if let Some(binding) = binding {
        let view = &mut app.render_workspace.view.materials;
        // Explicit stable revalidation may update a captured ordinal. Replace
        // the actual edited row instead of retaining an obsolete duplicate.
        let existing = view.bindings.iter().position(|b| b.target == binding.target || Some(&b.target) == original_target.as_ref());
        if removed {
            if let Some(index) = existing {
                view.bindings.remove(index);
            }
        } else if app.session.revision == before {
            // Opening the editor alone never allocates an inactive assignment.
            if (binding.saved_source.is_some() || (binding.saved_coat_source.is_some() && !binding.has_local_map_intent())) && !binding.active() {
                if let Some(index) = existing {
                    view.bindings.remove(index);
                }
            } else if binding.glass_enabled || binding.coat_enabled || binding.maps_enabled || existing.is_some() {
                if existing.is_none() {
                    view.enabled = true;
                }
                if let Some(index) = existing {
                    if let Some(slot) = view.bindings.get_mut(index) {
                        *slot = binding;
                    }
                } else if view.bindings.len() < MAX_BINDINGS {
                    view.bindings.push(binding);
                } else {
                    app.set_status(app.tr("render.material_limits").to_owned(), true);
                }
            }
        }
    }
}

fn saved_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) -> bool {
    let saved = app
        .render_workspace
        .view
        .draft
        .optics
        .iter()
        .enumerate()
        .find(|(_, saved)| binding.target.stable_target.as_ref() == Some(&saved.target))
        .map(|(index, saved)| (index, saved.target.clone()));
    ui_kit::banner(ui, ui_kit::AssistantTone::Working, |ui| {
        note(
            app,
            ui,
            if ((saved.is_some() && binding.saved_source.is_some()) || binding.saved_coat_source.is_some()) && !binding.active() {
                "render.appearance_editor.saved_state"
            } else {
                "render.appearance_editor.temporary"
            },
        );
    });
    let can_save = binding.enabled
        && binding.glass_enabled
        && binding.current(app)
        && !binding.maps_enabled
        && !binding.coat_enabled
        && matches!(app.render_workspace.view.method, super::ImageMethod::CpuRaytrace | super::ImageMethod::GpuRaytrace);
    let mut removed = false;
    ui.horizontal(|ui| {
        let save = ui_kit::button(ui, app.tr("render.appearance_editor.save"), ui_kit::Button::Enabled(can_save));
        crate::scenario::publish_target("render:optics-save", save.rect);
        if save.clicked() {
            match save_optics(app, binding) {
                Ok(()) => removed = true,
                Err(error) => app.set_status(error, true),
            }
        }
        let remove = ui_kit::button(ui, app.tr("render.appearance_editor.remove"), ui_kit::Button::Enabled(saved.is_some()));
        crate::scenario::publish_target("render:optics-remove", remove.rect);
        if remove.clicked()
            && let Some((index, target)) = saved
        {
            crate::scenario::publish_target(&format!("render:optics-remove:{index}"), remove.rect);
            app.render_workspace.view.materials.pending_remove = Some(PendingRemoval {
                coat: false,
                name: app.render_workspace.view.name.clone(),
                target,
                revision: app.session.revision,
                document: Arc::downgrade(&app.session.doc),
            });
        }
    });
    if binding.saved_source.is_some() && binding.active() {
        note(app, ui, "render.material_saved_edit_pending");
        let discard = ui_kit::button(ui, app.tr("render.appearance_editor.discard_saved_edit"), ui_kit::Button::Normal);
        crate::scenario::publish_target("render:optics-discard-edit", discard.rect);
        removed |= discard.clicked();
    }
    ui_kit::checkbox(ui, app.tr("render.appearance_editor.replace"), &mut binding.replace_saved_optics);
    if !can_save {
        note(app, ui, "render.appearance_editor.save_reason");
    }
    if !binding.current(app) {
        note(app, ui, "render.material_revalidate_needed");
    }
    if ui_kit::button(ui, app.tr("render.appearance_editor.revalidate"), ui_kit::Button::Normal).clicked()
        && let Err(error) = revalidate(app, binding)
    {
        app.set_status(error, true);
    }
    super::library::saved_surface_target_controls(app, ui, binding.target.stable_target.as_ref());
    removed
}

fn reflection_section(app: &mut SolveApp, ui: &mut egui::Ui, body: Option<&str>) {
    let reason = if body.is_none() {
        Some(app.tr("render.appearance_editor.body_reason").to_owned())
    } else if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace {
        Some(app.tr("render.appearance_editor.cpu_reason").to_owned())
    } else {
        None
    };
    let title = app.tr("render.appearance_editor.reflections").to_owned();
    ui_kit::method_section(ui, "render:appearance:reflections", &title, "CPU", reason.as_deref(), |ui| {
        use solidcraft_engine::render::job::ReflectionMode;
        let name = body.unwrap_or_default();
        let mut mode = app
            .render_workspace
            .view
            .raytrace
            .reflections
            .as_ref()
            .and_then(|r| r.bodies.iter().find(|b| b.body == name))
            .map_or(0, |b| if b.mode == ReflectionMode::Mirror { 1 } else { 2 });
        let labels = ["render.cpu_reflection_off", "render.cpu_reflection_mirror", "render.cpu_reflection_rough"].map(|key| app.tr(key).to_owned());
        let body_label = app.tr("render.inspector_this_body").to_owned();
        ui_kit::row(ui, &body_label, |ui| {
            if ui_kit::segmented(
                ui,
                &mut mode,
                &labels.each_ref().map(String::as_str),
                ui_kit::Segments { compact: true, small: true, ..Default::default() },
            ) {
                let value = match mode {
                    1 => Some(ReflectionMode::Mirror),
                    2 => Some(ReflectionMode::RoughSpecular),
                    _ => None,
                };
                if let Err(error) = super::cpu::set_reflection(app, name, value) {
                    app.set_status(error, true);
                }
            }
        });
        if ui_kit::button(ui, app.tr("render.cpu_binding_confirm"), ui_kit::Button::Enabled(mode != 0)).clicked()
            && let Err(error) = super::cpu::revalidate(app, name)
        {
            app.set_status(error, true);
        }
        let title = app.tr("render.appearance_editor.reflection_sampling").to_owned();
        ui_kit::editor_section(ui, "render:appearance:reflection-sampling", &title, false, |ui| super::cpu::reflection_sampling_controls(app, ui));
    });
}

pub(super) fn confirmation_open(app: &SolveApp) -> bool {
    app.render_workspace.view.materials.pending_remove.is_some()
}

pub(super) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
    let Some(pending) = app.render_workspace.view.materials.pending_remove.clone() else { return };
    if pending.revision != app.session.revision
        || pending.name != app.render_workspace.view.name
        || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc))
    {
        app.render_workspace.view.materials.pending_remove = None;
        app.set_status(app.tr("render.review_stale").to_owned(), true);
        return;
    }
    let title = app.tr(if pending.coat { "render.coat_remove_title" } else { "render.appearance_editor.remove_title" }).to_owned();
    let (closed, action) = ui_kit::Confirm::new(egui::Id::unique("render_remove_optics"), "delete", &title)
        .tone(ui_kit::Tone::Danger)
        .actions(app.tr("render.appearance_editor.remove"), app.tr("render.keep_editing"), None)
        .selected(ui_kit::Action::Cancel)
        .show(ctx, true, |ui| {
            note(app, ui, if pending.coat { "render.coat_remove_note" } else { "render.appearance_editor.remove_note" });
        });
    if closed || action == ui_kit::Action::Cancel {
        app.render_workspace.view.materials.pending_remove = None;
    }
    if action == ui_kit::Action::Ok {
        app.render_workspace.view.materials.pending_remove = None;
        let command = if pending.coat { "render.coat.unbind" } else { "render.optics.unbind" };
        match app.run(command, json!({"name":pending.name,"target":&pending.target,"expected_revision":pending.revision})) {
            Ok(_) => {
                // Removing one saved binding must preserve unsaved shot settings
                // and unrelated temporary overrides on this tab.
                if pending.coat {
                    app.render_workspace.view.draft.coats.remove(&pending.target);
                    let revision = app.session.revision;
                    let document = Arc::downgrade(&app.session.doc);
                    app.render_workspace.view.materials.bindings.retain_mut(|binding| {
                        if binding.target.stable_target.as_ref() != Some(&pending.target) {
                            return true;
                        }
                        if !binding.has_local_map_intent() {
                            return false;
                        }
                        binding.saved_coat_source = None;
                        binding.coat_enabled = false;
                        binding.coat_edited = false;
                        binding.revision = revision;
                        binding.document = document.clone();
                        true
                    });
                } else {
                    app.render_workspace.view.draft.optics.remove(&pending.target);
                }
            }
            Err(error) => app.set_status(error, true),
        }
    }
}