dc38349cbf
* 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>
170 lines
6.3 KiB
Rust
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()
|
|
);
|
|
}
|
|
}
|