Files
makeCAD/crates/doc/src/render_optics.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

170 lines
6.3 KiB
Rust

//! Portable render-only optical assignments with stable definition/occurrence
//! identity. These are authored optical numbers, not engineering material cards.
use crate::{
DocError, Result,
render_surface::{RenderBodyTarget, bounded_sequence},
};
use serde::{Deserialize, Serialize};
use solidcore_record::Vec3;
use solidcraft_render::{
surface::OpaqueSurface,
transmission::{Transmission, subsurface::Subsurface},
};
use std::collections::BTreeSet;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum OpticalBoundary {
ThinSheet,
ClosedBox,
#[default]
ClosedMesh,
}
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct OpticalMaterial {
pub ior: f64,
pub absorption_per_mm: [f64; 3],
pub boundary: OpticalBoundary,
pub thickness_mm: f64,
pub shadow_transmission: bool,
pub subsurface: Option<Subsurface>,
}
impl Default for OpticalMaterial {
fn default() -> Self {
Self { ior: 1.5, absorption_per_mm: [0.0; 3], boundary: Default::default(), thickness_mm: 0.0, shadow_transmission: false, subsurface: None }
}
}
impl OpticalMaterial {
pub fn validate(self) -> Result<()> {
let error = |message: String| DocError::Invalid(message);
OpaqueSurface::new(Vec3::ZERO, 0.0, 0.5, self.ior).map_err(|e| error(e.to_string()))?;
if self.boundary != OpticalBoundary::ThinSheet && self.thickness_mm != 0.0 {
return Err(error("closed optical thickness comes from geometry; thickness_mm must be zero".into()));
}
let [r, g, b] = self.absorption_per_mm;
let medium = Transmission::new(Vec3::new(r, g, b), (self.boundary == OpticalBoundary::ThinSheet).then_some(self.thickness_mm))
.map_err(|e| error(e.to_string()))?
.with_shadow_transmission(self.shadow_transmission);
if let Some(scatter) = self.subsurface {
medium.with_subsurface(scatter).map_err(|e| error(e.to_string()))?;
}
Ok(())
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SavedOptics {
pub target: RenderBodyTarget,
pub optics: OpticalMaterial,
}
impl SavedOptics {
pub fn validate(&self) -> Result<()> {
self.target.validate()?;
self.optics.validate()
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(transparent)]
pub struct OpticalBindings(Vec<SavedOptics>);
impl OpticalBindings {
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn iter(&self) -> impl Iterator<Item = &SavedOptics> {
self.0.iter()
}
pub fn validate(&self) -> Result<()> {
if self.0.len() > 32 || self.0.capacity() > 32 {
return Err(DocError::Invalid("at most 32 portable optical targets".into()));
}
let mut seen = BTreeSet::new();
for binding in &self.0 {
binding.validate()?;
if !seen.insert(&binding.target) {
return Err(DocError::Invalid("duplicate portable optical target".into()));
}
}
Ok(())
}
pub fn set(&mut self, binding: SavedOptics, replace: bool) -> Result<()> {
binding.validate()?;
if let Some(old) = self.0.iter_mut().find(|old| old.target == binding.target) {
if old == &binding {
return Ok(());
}
if !replace {
return Err(DocError::Invalid("optical target already exists; explicit replacement consent required".into()));
}
*old = binding;
} else {
if self.0.len() >= 32 {
return Err(DocError::Invalid("at most 32 portable optical targets".into()));
}
self.0.try_reserve_exact(1).map_err(|_| DocError::Invalid("optical binding reservation failed".into()))?;
if self.0.capacity() > 32 {
return Err(DocError::Invalid("optical capacity exceeds its bound".into()));
}
self.0.push(binding);
}
Ok(())
}
pub fn remove(&mut self, target: &RenderBodyTarget) -> bool {
let n = self.0.len();
self.0.retain(|b| &b.target != target);
n != self.0.len()
}
}
impl<'de> Deserialize<'de> for OpticalBindings {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
let result = Self(bounded_sequence::<D, SavedOptics, 32>(d)?);
result.validate().map_err(serde::de::Error::custom)?;
Ok(result)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn portable_optics_roundtrip_with_explicit_replacement_and_no_runtime_ordinal() {
let target = RenderBodyTarget { definition: "Diffuser".into(), feature: 1, component: 0, occurrence_path: vec![] };
let mut bindings = OpticalBindings::default();
let one = SavedOptics {
target: target.clone(),
optics: OpticalMaterial { subsurface: Some(Subsurface { scattering_per_mm: 0.8, anisotropy: 0.3 }), ..Default::default() },
};
bindings.set(one.clone(), false).unwrap();
let wire = serde_json::to_value(&bindings).unwrap();
assert!(wire[0].get("body_index").is_none());
assert_eq!(serde_json::from_value::<OpticalBindings>(wire).unwrap(), bindings);
let mut two = one;
two.optics.ior = 1.2;
assert!(bindings.set(two.clone(), false).is_err());
bindings.set(two, true).unwrap();
assert!(bindings.remove(&target));
assert!(bindings.is_empty());
assert!(OpticalMaterial { thickness_mm: 1.0, ..Default::default() }.validate().is_err());
assert!(
OpticalMaterial {
boundary: OpticalBoundary::ThinSheet,
subsurface: Some(Subsurface { scattering_per_mm: 1.0, anisotropy: 0.0 }),
..Default::default()
}
.validate()
.is_err()
);
assert!(
OpticalMaterial {
shadow_transmission: true,
subsurface: Some(Subsurface { scattering_per_mm: 1.0, anisotropy: 0.0 }),
..Default::default()
}
.validate()
.is_err()
);
}
}