Skip to content

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

8.4 KB
Raw Blame
//! Read-only light inspection. No host, geometry evaluation, camera or design mutation.

use serde_json::Value;
use solidcraft_doc::render_settings::{RenderSettings, RenderSetup};

use crate::params::bad;
use crate::schema::render_lights::{EditParams, EditResult, Geometry, Light, LightIdRemap};
use crate::schema::render_lights::{ListParams, ListResult};
use crate::{Result, Session};

pub(super) fn list(s: &mut Session, params: &Value) -> Result<Value> {
    let cmd = "render.lights.list";
    if !params.is_object() {
        return Err(bad(cmd, "expected an object"));
    }
    let request: ListParams = serde_json::from_value(params.clone()).map_err(|e| bad(cmd, e.to_string()))?;
    if params.get("setup").is_some_and(Value::is_null) || params.get("settings").is_some_and(Value::is_null) {
        return Err(bad(cmd, "setup and settings cannot be null"));
    }
    let setup = match (request.setup, request.settings) {
        (Some(_), Some(_)) => return Err(bad(cmd, "choose setup or settings, not both")),
        (Some(name), None) => {
            RenderSettings::validate_name(&name).map_err(|e| bad(cmd, e.to_string()))?;
            s.doc.render.setups.get(&name).cloned().ok_or_else(|| bad(cmd, "no saved render setup with that name"))?
        }
        (None, Some(settings)) => {
            if !settings.is_object() {
                return Err(bad(cmd, "settings must be an object"));
            }
            serde_json::from_value(settings).map_err(|e| bad(cmd, e.to_string()))?
        }
        (None, None) => RenderSetup::default(),
    };
    setup.validate().map_err(|e| bad(cmd, e.to_string()))?;
    serde_json::to_value(ListResult { lights: crate::render_lights::inspect(&setup).map_err(|e| bad(cmd, e))? }).map_err(|e| bad(cmd, e.to_string()))
}

fn canonical_id(setup: &RenderSetup, lights: &[Light], index: usize) -> Option<String> {
    lights.get(index).map(|light| {
        let kind = light.geometry.kind();
        let finite_directional = matches!(
            setup.job,
            Some(solidcraft_doc::render_settings::RenderJob::GpuPath { .. } | solidcraft_doc::render_settings::RenderJob::CpuRaytrace { .. })
        ) && kind == "directional";
        let slot = if finite_directional {
            if matches!(light.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. }) {
                0
            } else {
                usize::from(lights.iter().any(|l| matches!(l.geometry, Geometry::Directional { angular_radius_rad: Some(_), .. })))
                    + lights.iter().take(index).filter(|l| matches!(l.geometry, Geometry::Directional { angular_radius_rad: None, .. })).count()
            }
        } else {
            lights
                .iter()
                .take(index)
                .filter(|prior| {
                    if matches!(kind, "point" | "spot") { matches!(prior.geometry.kind(), "point" | "spot") } else { prior.geometry.kind() == kind }
                })
                .count()
        };
        format!("{kind}:{slot}")
    })
}

fn change(s: &mut Session, params: &Value, operation: &str) -> Result<Value> {
    let command = format!("render.lights.{operation}");
    if !params.is_object() {
        return Err(bad(&command, "expected an object"));
    }
    let input: EditParams = serde_json::from_value(params.clone()).map_err(|e| bad(&command, e.to_string()))?;
    RenderSettings::validate_name(&input.name).map_err(|e| bad(&command, e.to_string()))?;
    if input.expected_revision.is_some_and(|revision| revision != s.revision) {
        return Err(bad(&command, "light settings changed; refresh before editing"));
    }
    let mut setup = match input.settings {
        Some(value) if value.is_object() => serde_json::from_value::<RenderSetup>(value).map_err(|e| bad(&command, e.to_string()))?,
        Some(_) => return Err(bad(&command, "settings must be an object")),
        None => s.doc.render.setups.get(&input.name).cloned().unwrap_or_default(),
    };
    let mut lights = crate::render_lights::inspect(&setup).map_err(|e| bad(&command, e))?;
    let original_lights = lights.clone();
    let target = [setup.camera.target.x, setup.camera.target.y, setup.camera.target.z];
    let mut selected = None;
    match operation {
        "add" => {
            if input.id.is_some() {
                return Err(bad(&command, "add does not accept an id"));
            }
            let mut patch = input.set.unwrap_or_default();
            if patch.kind.is_none() {
                patch.kind = Some("area".into());
            }
            let [x, y, z] = target;
            let mut light = Light {
                id: String::new(),
                name: String::new(),
                name_key: String::new(),
                number: 0,
                implicit: false,
                intensity: 1.0,
                colour: [1.0; 3],
                geometry: Geometry::Area { position_mm: [x, y - 100.0, z + 100.0], edge_u_mm: [10.0, 0.0, 0.0], edge_v_mm: [0.0, -10.0, 0.0] },
            };
            crate::render_lights::patch(&mut light, &patch, target, setup.camera.distance).map_err(|e| bad(&command, e))?;
            lights.push(light);
            selected = lights.len().checked_sub(1);
        }
        "set" | "duplicate" | "remove" => {
            let id = input.id.as_deref().ok_or_else(|| bad(&command, "id is required"))?;
            crate::render_lights::parse_id(id).map_err(|e| bad(&command, e))?;
            let index = lights.iter().position(|light| light.id == id).ok_or_else(|| bad(&command, "light no longer exists"))?;
            if operation == "remove" {
                if input.set.is_some() {
                    return Err(bad(&command, "remove does not accept set"));
                }
                lights.retain(|light| light.id != id);
            } else if operation == "duplicate" {
                if input.set.is_some() {
                    return Err(bad(&command, "duplicate does not accept set"));
                }
                let mut light = lights.get(index).cloned().ok_or_else(|| bad(&command, "missing light"))?;
                // A new source, even when every numerical value equals its parent.
                light.id.clear();
                lights.push(light);
                selected = lights.len().checked_sub(1);
            } else {
                let patch = input.set.ok_or_else(|| bad(&command, "set is required"))?;
                let light = lights.get_mut(index).ok_or_else(|| bad(&command, "missing light"))?;
                if matches!(&setup.job, Some(solidcraft_doc::render_settings::RenderJob::CpuRaytrace { options, .. }) if options.path.is_none())
                    && light.geometry.kind() == "directional"
                    && patch.softness.is_some()
                {
                    return Err(bad(&command, "CPU directional lights have hard shadows; softness is not supported"));
                }
                crate::render_lights::patch(light, &patch, target, setup.camera.distance).map_err(|e| bad(&command, e))?;
                selected = Some(index);
            }
        }
        _ => return Err(bad(&command, "unknown light operation")),
    }
    let id = selected.and_then(|index| canonical_id(&setup, &lights, index));
    let id_remap = lights
        .iter()
        .enumerate()
        .filter_map(|(index, light)| {
            original_lights
                .iter()
                .find(|before| !light.id.is_empty() && before.id == light.id)
                .and_then(|before| canonical_id(&setup, &lights, index).map(|after_id| LightIdRemap { before: before.clone(), after_id }))
        })
        .collect();
    crate::render_lights::write(&mut setup, &lights).map_err(|e| bad(&command, e))?;
    let mut settings = (*s.doc.render).clone();
    settings.setups.insert(input.name.clone(), setup.clone());
    settings.validate().map_err(|e| bad(&command, e.to_string()))?;
    if *s.doc.render != settings {
        s.doc_mut().render = std::sync::Arc::new(settings);
    }
    serde_json::to_value(EditResult { id, id_remap, name: input.name, setup: serde_json::to_value(setup).map_err(|e| bad(&command, e.to_string()))? })
        .map_err(|e| bad(&command, e.to_string()))
}

pub(super) fn set(s: &mut Session, p: &Value) -> Result<Value> {
    change(s, p, "set")
}
pub(super) fn add(s: &mut Session, p: &Value) -> Result<Value> {
    change(s, p, "add")
}
pub(super) fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
    change(s, p, "duplicate")
}
pub(super) fn remove(s: &mut Session, p: &Value) -> Result<Value> {
    change(s, p, "remove")
}