SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Cooperative certification of the exact f64 boundary consumed by CPU Path.
//! Coordinates are never tolerance-welded, snapped or repaired. Every shared edge must have
//! identical finite endpoints (ClosedMesh and sheets canonicalise signed zero; declared
//! boxes retain the legacy raw-bit edge policy). Sheets may have manifold boundary
//! edges, concavity and holes; geometric contact is
//! permitted only along the same body's actual shared topological simplex.
use super::{Bounds, Triangle, WorkBudget};
use crate::{
ProductScene,
job::{self, CancelToken, DielectricBoundary, RaytraceOptions},
};
use robust::{Coord, Coord3D, orient2d, orient3d};
use solidcore_record::Vec3;
use std::mem::size_of;
fn invalid(message: &str) -> job::JobError {
job::JobError::new(job::ErrorCode::InvalidScene, message)
}
fn memory() -> job::JobError {
job::JobError::new(job::ErrorCode::LimitExceeded, "CPU glass certification memory exceeds admission")
}
fn reserved<T>(n: usize) -> job::Result<Vec<T>> {
let mut values = Vec::new();
values.try_reserve_exact(n).map_err(|_| job::JobError::new(job::ErrorCode::AllocationFailed, "CPU glass certification allocation failed"))?;
if values.capacity() != n {
return Err(memory());
}
Ok(values)
}
// Keep adaptive determinant expansions away from IEEE underflow. This is a
// conservative certificate domain, not a snap tolerance or a changed ray bound.
// With coordinates in [2^-128, 1e12] (or exactly zero), each nonzero f64
// difference is at least 2^-180 and the degree-three expansion products remain
// normal. Original legacy optics have no new coordinate restriction.
fn predicate_domain(points: &[Vec3]) -> job::Result<()> {
let minimum = f64::from_bits((1023 - 128) << 52);
if points.iter().flat_map(|p| [p.x, p.y, p.z]).any(|v| !v.is_finite() || v.abs() > super::MAX_COORDINATE_MM || (v != 0.0 && v.abs() < minimum)) {
return Err(invalid("CPU exact glass certificate requires zero or coordinate magnitudes at least 2^-128 mm within the existing world bound"));
}
Ok(())
}
fn point(p: Vec3) -> Coord3D<f64> {
Coord3D { x: p.x, y: p.y, z: p.z }
}
fn side(t: [Vec3; 3], p: Vec3) -> f64 {
orient3d(point(t[0]), point(t[1]), point(t[2]), point(p))
}
fn key(p: Vec3) -> [u64; 3] {
[p.x, p.y, p.z].map(|v| if v == 0.0 { 0 } else { v.to_bits() })
}
fn target_key(p: Vec3, medium: usize, options: &RaytraceOptions) -> job::Result<[u64; 3]> {
let input = options.dielectrics.get(medium).ok_or_else(|| invalid("CPU glass coordinate target"))?;
Ok(if input.boundary == DielectricBoundary::ClosedBox { [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()] } else { key(p) })
}
fn same(a: Vec3, b: Vec3) -> bool {
key(a) == key(b)
}
fn projection(t: [Vec3; 3]) -> usize {
for drop in 0..3 {
let q = t.map(|p| project(p, drop));
if orient2d(q[0], q[1], q[2]) != 0.0 {
return drop;
}
}
2
}
fn project(p: Vec3, drop: usize) -> Coord<f64> {
match drop {
0 => Coord { x: p.y, y: p.z },
1 => Coord { x: p.z, y: p.x },
_ => Coord { x: p.x, y: p.y },
}
}
fn in_triangle(t: [Vec3; 3], p: Vec3, drop: usize) -> bool {
let q = t.map(|p| project(p, drop));
let p = project(p, drop);
let s = [orient2d(q[0], q[1], p), orient2d(q[1], q[2], p), orient2d(q[2], q[0], p)];
!s.iter().any(|v| *v < 0.0) || !s.iter().any(|v| *v > 0.0)
}
fn on_segment(a: Coord<f64>, b: Coord<f64>, p: Coord<f64>) -> bool {
orient2d(a, b, p) == 0.0 && p.x >= a.x.min(b.x) && p.x <= a.x.max(b.x) && p.y >= a.y.min(b.y) && p.y <= a.y.max(b.y)
}
fn opposite(a: f64, b: f64) -> bool {
(a < 0.0 && b > 0.0) || (a > 0.0 && b < 0.0)
}
fn shared_vertex(p: Vec3, a: [Vec3; 3], b: [Vec3; 3]) -> bool {
a.into_iter().any(|x| same(x, p)) && b.into_iter().any(|x| same(x, p))
}
fn coplanar_edge_bad(edges: [[Vec3; 2]; 2], triangles: [[Vec3; 3]; 2], allow_shared: bool, drop: usize) -> bool {
let [[a, b], [c, d]] = edges;
let [ta, tb] = triangles;
let [pa, pb, pc, pd] = [a, b, c, d].map(|p| project(p, drop));
let s = [orient2d(pa, pb, pc), orient2d(pa, pb, pd), orient2d(pc, pd, pa), orient2d(pc, pd, pb)];
if opposite(s[0], s[1]) && opposite(s[2], s[3]) {
return true;
}
for (p, q, r) in [(a, pc, pd), (b, pc, pd), (c, pa, pb), (d, pa, pb)] {
if on_segment(q, r, project(p, drop)) && (!allow_shared || !shared_vertex(p, ta, tb)) {
return true;
}
}
// If collinear overlap has positive length, it is legal only for the exact
// shared topological edge, not two incident edges extending the same way.
if s.into_iter().all(|v| v == 0.0) {
let axis_x = (pa.x - pb.x).abs() >= (pa.y - pb.y).abs();
let value = |p: Coord<f64>| if axis_x { p.x } else { p.y };
let lo = value(pa).min(value(pb)).max(value(pc).min(value(pd)));
let hi = value(pa).max(value(pb)).min(value(pc).max(value(pd)));
if lo < hi && !(allow_shared && ((same(a, c) && same(b, d)) || (same(a, d) && same(b, c)))) {
return true;
}
}
false
}
/// True if the two exact triangles meet beyond their permitted shared simplex.
/// This uses signs of adaptive exact predicates; no distance/angle tolerance.
pub(super) fn forbidden_contact(a: [Vec3; 3], b: [Vec3; 3], allow_shared: bool) -> bool {
let sa = a.map(|p| side(b, p));
let sb = b.map(|p| side(a, p));
if sa.iter().all(|v| *v > 0.0) || sa.iter().all(|v| *v < 0.0) || sb.iter().all(|v| *v > 0.0) || sb.iter().all(|v| *v < 0.0) {
return false;
}
let common = a.iter().filter(|p| b.iter().any(|q| same(**p, *q))).count();
if common == 3 {
return true;
}
for (t, u, s) in [(a, b, sa), (b, a, sb)] {
let drop = projection(u);
for (p, sign) in t.into_iter().zip(s) {
if sign == 0.0 && in_triangle(u, p, drop) && (!allow_shared || !shared_vertex(p, a, b)) {
return true;
}
}
for (i, j) in [(0, 1), (1, 2), (2, 0)] {
let p = t[i];
let q = t[j];
if opposite(s[i], s[j]) {
let w = [side([p, q, u[0]], u[1]), side([p, q, u[1]], u[2]), side([p, q, u[2]], u[0])];
if !w.iter().any(|v| *v < 0.0) || !w.iter().any(|v| *v > 0.0) {
return true;
}
} else if s[i] == 0.0 && s[j] == 0.0 {
for (k, l) in [(0, 1), (1, 2), (2, 0)] {
if coplanar_edge_bad([[p, q], [u[k], u[l]]], [a, b], allow_shared, drop) {
return true;
}
}
}
}
}
false
}
#[derive(Clone, Copy)]
struct Face {
p: [Vec3; 3],
medium: usize,
}
#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
struct Edge {
medium: usize,
a: [u64; 3],
b: [u64; 3],
face: usize,
forward: bool,
}
#[derive(Clone, Copy)]
pub(super) struct Region {
pub bounds: Bounds,
pub parent: Option<usize>,
begin: usize,
end: usize,
pub primitive_begin: usize,
pub primitive_end: usize,
}
impl Default for Region {
fn default() -> Self {
Self { bounds: Bounds::empty(), parent: None, begin: 0, end: 0, primitive_begin: 0, primitive_end: 0 }
}
}
#[derive(Clone, Copy)]
enum Stage {
Index,
Load,
BoxAxes,
Edges,
Sort,
Pairs,
Connected,
CornerInit,
CornerEdges,
CornerRecords,
VertexLinks,
Contact,
Sources,
Volume,
Parents,
Convex,
Inside,
Done,
}
/// All vectors reserve their admitted exact capacity before preparation begins.
/// Sorting is an iterative merge: a continuation copies at most one edge.
pub(super) struct Task {
faces: Vec<Face>,
edges: Vec<Edge>,
scratch: Vec<Edge>,
parents: Vec<usize>,
ranks: Vec<u8>,
regions: [Region; 8],
count: usize,
stage: Stage,
vertex_sort: bool,
medium: usize,
triangle: usize,
i: usize,
j: usize,
width: usize,
begin: usize,
left: usize,
right: usize,
end: usize,
out: usize,
pair: (usize, usize),
vertex: usize,
outer: usize,
inner: usize,
volume: super::glass_volume::SignedVolume,
}
fn selected_count(scene: &ProductScene, options: &RaytraceOptions) -> job::Result<usize> {
let mut count = 0_usize;
for input in &options.dielectrics {
let body = scene.meshes.get(input.body_index).filter(|b| b.name == input.body_name).ok_or_else(|| invalid("CPU glass target changed"))?;
count = count.checked_add(body.mesh.triangles.len()).ok_or_else(memory)?;
}
if count as u64 > options.budget.limits().max_triangles {
return Err(memory());
}
Ok(count)
}
impl Task {
pub(super) fn required_bytes(scene: &ProductScene, options: &RaytraceOptions) -> job::Result<u64> {
let n = selected_count(scene, options)?;
n.checked_mul(size_of::<Face>() + 6 * size_of::<Edge>() + 3 * size_of::<usize>() + 3 * size_of::<u8>())
.and_then(|n| n.checked_add(size_of::<Self>()))
.and_then(|n| u64::try_from(n).ok())
.ok_or_else(memory)
}
pub(super) fn new(scene: &ProductScene, options: &RaytraceOptions) -> job::Result<Self> {
options.validate()?;
let n = selected_count(scene, options)?;
let edges = n.checked_mul(3).ok_or_else(memory)?;
Ok(Self {
faces: reserved(n)?,
edges: reserved(edges)?,
scratch: reserved(edges)?,
parents: reserved(edges)?,
ranks: reserved(edges)?,
regions: [Region::default(); 8],
count: options.dielectrics.len(),
stage: Stage::Index,
vertex_sort: false,
medium: 0,
triangle: 0,
i: 0,
j: 1,
width: 1,
begin: 0,
left: 0,
right: 0,
end: 0,
out: 0,
pair: (0, 1),
vertex: 0,
outer: 0,
inner: 0,
volume: Default::default(),
})
}
pub(super) fn ready(&self) -> bool {
matches!(self.stage, Stage::Done)
}
pub(super) fn region(&self, index: usize) -> job::Result<Region> {
self.regions.get(index).copied().filter(|_| self.ready()).ok_or_else(|| invalid("CPU glass certificate missing"))
}
fn root(&self, mut n: usize) -> job::Result<usize> {
// Union by rank bounds the tree by log2(number of corners). The explicit bound also protects
// malformed private state; every parent chase is finite and cancellable
// at the surrounding per-edge continuation.
for _ in 0..64 {
let p = *self.parents.get(n).ok_or_else(|| invalid("CPU glass component index"))?;
if p == n {
return Ok(n);
}
n = p;
}
Err(invalid("CPU glass component chain exceeds its bounded certificate"))
}
fn join(&mut self, ra: usize, rb: usize) -> job::Result<()> {
if ra != rb {
let ar = *self.ranks.get(ra).ok_or_else(|| invalid("CPU glass union rank"))?;
let br = *self.ranks.get(rb).ok_or_else(|| invalid("CPU glass union rank"))?;
let (keep, merge) = if ar < br { (rb, ra) } else { (ra, rb) };
*self.parents.get_mut(merge).ok_or_else(|| invalid("CPU glass union index"))? = keep;
if ar == br {
let r = self.ranks.get_mut(keep).ok_or_else(|| invalid("CPU glass union rank"))?;
*r = r.checked_add(1).ok_or_else(|| invalid("CPU glass union rank overflow"))?;
}
}
Ok(())
}
fn next_pair(&mut self) {
self.pair.1 += 1;
if self.pair.1 >= self.faces.len() {
self.pair.0 += 1;
self.pair.1 = self.pair.0 + 1;
}
}
pub(super) fn step(&mut self, scene: &ProductScene, options: &RaytraceOptions, work: &mut WorkBudget, cancel: &CancelToken) -> job::Result<()> {
work.tick(cancel).map_err(super::image::error)?;
match self.stage {
Stage::Index => {
if let Some(body) = scene.meshes.get(self.medium) {
for (index, input) in options.dielectrics.iter().enumerate() {
if input.body_index == self.medium {
let region = self.regions.get_mut(index).ok_or_else(|| invalid("CPU glass primitive range"))?;
region.primitive_begin = self.i;
region.primitive_end = self.i.checked_add(body.mesh.triangles.len()).ok_or_else(memory)?;
match input.boundary {
// Path sheets use this task's charged planar/manifold proof.
DielectricBoundary::ThinSheet => {}
DielectricBoundary::ClosedBox => {
if !(12..=super::dielectric::MAX_BOX_TRIANGLES).contains(&body.mesh.triangles.len()) {
return Err(invalid("unsupported dielectric boundary tessellation"));
}
}
DielectricBoundary::ClosedMesh => {}
}
}
}
self.i = self.i.checked_add(body.mesh.triangles.len()).ok_or_else(memory)?;
self.medium += 1;
} else {
self.i = 0;
self.medium = 0;
self.stage = Stage::Load;
}
}
Stage::Load => {
let Some(input) = options.dielectrics.get(self.medium) else {
self.i = 0;
self.stage = if options.dielectrics.iter().any(|input| input.boundary == DielectricBoundary::ClosedBox) {
Stage::BoxAxes
} else {
Stage::Edges
};
return Ok(());
};
let body =
scene.meshes.get(input.body_index).filter(|b| b.name == input.body_name).ok_or_else(|| invalid("CPU glass target changed"))?;
let region = self.regions.get_mut(self.medium).ok_or_else(|| invalid("CPU glass region index"))?;
if self.triangle == 0 {
region.begin = self.faces.len();
}
let Some(indices) = body.mesh.triangles.get(self.triangle) else {
region.end = self.faces.len();
if region.end == region.begin {
return Err(invalid("CPU glass boundary has no triangles"));
}
self.medium += 1;
self.triangle = 0;
return Ok(());
};
let mut p = [Vec3::ZERO; 3];
for (v, index) in p.iter_mut().zip(indices) {
*v = *body.mesh.positions.get(*index as usize).ok_or_else(|| invalid("CPU glass vertex index"))?;
}
predicate_domain(&p)?;
if Triangle::new(p).map_err(super::image::error)?.geometric_normal().is_none() {
return Err(invalid("CPU glass boundary contains a degenerate triangle"));
}
region.bounds = region.bounds.include(Triangle::new(p).map_err(super::image::error)?.bounds());
if input.boundary == DielectricBoundary::ThinSheet
&& let Some(first) = self.faces.get(region.begin)
{
if !same_plane(first.p, p) {
return Err(invalid("CPU thin sheet must have one exact planar boundary"));
}
let drop = projection(first.p);
let a = first.p.map(|p| project(p, drop));
let b = p.map(|p| project(p, drop));
let winding = orient2d(b[0], b[1], b[2]);
if winding == 0.0 || opposite(orient2d(a[0], a[1], a[2]), winding) {
return Err(invalid("CPU thin sheet triangles must have consistent winding"));
}
}
if self.faces.len() == self.faces.capacity() {
return Err(memory());
}
self.parents.push(self.faces.len());
self.ranks.push(0);
self.faces.push(Face { p, medium: self.medium });
self.triangle += 1;
}
Stage::BoxAxes => {
if let Some(face) = self.faces.get(self.i) {
let input = options.dielectrics.get(face.medium).ok_or_else(|| invalid("CPU box plane target"))?;
if input.boundary == DielectricBoundary::ClosedBox {
let normal = Triangle::new(face.p).map_err(super::image::error)?.geometric_normal().ok_or_else(|| invalid("box normal"))?;
let axis = if normal.x.abs() == 1.0 {
0
} else if normal.y.abs() == 1.0 {
1
} else if normal.z.abs() == 1.0 {
2
} else {
return Err(invalid("box face is not axis aligned"));
};
let bounds = self.regions.get(face.medium).ok_or_else(|| invalid("CPU box plane bounds"))?.bounds;
let positive = super::component(normal, axis) > 0.0;
// Region bounds union Triangle::bounds, whose finite extrema
// each take exactly one outward representable step. Undo
// only that padding for the raw face-plane comparison;
// keep the stored bounds and raw endpoint edge keys intact.
// The inverse is value-exact, including subnormals. ±0
// compare equally here; signed-zero topology still uses
// the original referenced coordinates' unchanged bits.
let padded = super::component(if positive { bounds.max() } else { bounds.min() }, axis);
let plane = if positive { padded.next_down() } else { padded.next_up() };
if face.p.iter().any(|p| super::component(*p, axis) != plane) {
return Err(invalid("box winding or face plane"));
}
self.i += 1;
} else {
self.i = self.regions.get(face.medium).ok_or_else(|| invalid("CPU box skip region"))?.end;
}
} else {
self.i = 0;
self.stage = Stage::Edges;
}
}
Stage::Edges => {
if let Some(face) = self.faces.get(self.i) {
for (a, b) in [(0, 1), (1, 2), (2, 0)] {
let a = target_key(face.p[a], face.medium, options)?;
let b = target_key(face.p[b], face.medium, options)?;
if a == b {
return Err(invalid("CPU glass collapsed edge"));
}
self.edges.push(Edge { medium: face.medium, a: a.min(b), b: a.max(b), face: self.i, forward: a < b });
self.scratch.push(Edge::default());
}
self.i += 1;
} else {
self.stage = Stage::Sort;
self.begin = 0;
self.out = 0;
}
}
Stage::Sort => {
if self.width >= self.edges.len() {
self.stage = if self.vertex_sort { Stage::VertexLinks } else { Stage::Pairs };
self.i = 0;
return Ok(());
}
if self.out == self.begin {
self.left = self.begin;
self.right = (self.begin + self.width).min(self.edges.len());
self.end = (self.right + self.width).min(self.edges.len());
}
let middle = (self.begin + self.width).min(self.edges.len());
let take_left = self.left < middle && (self.right >= self.end || self.edges.get(self.left) <= self.edges.get(self.right));
let at = if take_left {
let n = self.left;
self.left += 1;
n
} else {
let n = self.right;
self.right += 1;
n
};
let value = *self.edges.get(at).ok_or_else(|| invalid("CPU glass merge input"))?;
*self.scratch.get_mut(self.out).ok_or_else(|| invalid("CPU glass merge output"))? = value;
self.out += 1;
if self.out == self.end {
self.begin = self.end;
if self.begin == self.edges.len() {
std::mem::swap(&mut self.edges, &mut self.scratch);
self.width = self.width.checked_mul(2).ok_or_else(memory)?;
self.begin = 0;
self.out = 0;
}
}
}
Stage::Pairs => {
let Some(a) = self.edges.get(self.i).copied() else {
self.stage = Stage::Connected;
self.i = 0;
return Ok(());
};
let group = |x: Edge| (x.medium, x.a, x.b);
let Some(b) = self.edges.get(self.i + 1).copied().filter(|b| group(a) == group(*b)) else {
if options.dielectrics.get(a.medium).is_some_and(|input| input.boundary == DielectricBoundary::ThinSheet) {
self.i += 1;
return Ok(());
}
return Err(invalid("CPU glass requires closed edges"));
};
if a.forward == b.forward || self.edges.get(self.i + 2).is_some_and(|x| group(*x) == group(a)) {
return Err(invalid("CPU glass requires at most two oppositely wound faces per edge; closed boundaries require exactly two"));
}
let ra = self.root(a.face)?;
let rb = self.root(b.face)?;
self.join(ra, rb)?;
self.i += 2;
}
Stage::Connected => {
if let Some(face) = self.faces.get(self.i) {
let region = self.regions.get(face.medium).ok_or_else(|| invalid("CPU glass region missing"))?;
if self.root(self.i)? != self.root(region.begin)? {
return Err(invalid("each CPU glass body must contain one edge-connected boundary"));
}
self.i += 1;
} else {
self.stage = Stage::CornerInit;
self.i = 0;
}
}
Stage::CornerInit => {
let count = self.faces.len().checked_mul(3).ok_or_else(memory)?;
if self.i == count {
self.stage = Stage::CornerEdges;
self.i = 0;
self.vertex = 0;
return Ok(());
}
if let Some(parent) = self.parents.get_mut(self.i) {
*parent = self.i;
} else {
self.parents.push(self.i);
}
if let Some(rank) = self.ranks.get_mut(self.i) {
*rank = 0;
} else {
self.ranks.push(0);
}
self.i += 1;
}
Stage::CornerEdges => {
let Some(a) = self.edges.get(self.i).copied() else {
self.stage = Stage::CornerRecords;
self.i = 0;
return Ok(());
};
let Some(b) = self.edges.get(self.i + 1).copied().filter(|b| (a.medium, a.a, a.b) == (b.medium, b.a, b.b)) else {
// Sheet boundary edges have one face and do not join two
// corner records. Closed-edge completeness was proved above.
self.i += 1;
self.vertex = 0;
return Ok(());
};
let coordinate = if self.vertex == 0 { a.a } else { a.b };
let corner = |edge: Edge| -> job::Result<usize> {
let face = self.faces.get(edge.face).ok_or_else(|| invalid("CPU glass corner face"))?;
let mut local = None;
for (index, p) in face.p.into_iter().enumerate() {
if target_key(p, face.medium, options)? == coordinate {
local = Some(index);
break;
}
}
let local = local.ok_or_else(|| invalid("CPU glass corner endpoint"))?;
edge.face.checked_mul(3).and_then(|n| n.checked_add(local)).ok_or_else(memory)
};
let ra = self.root(corner(a)?)?;
let rb = self.root(corner(b)?)?;
self.join(ra, rb)?;
self.vertex += 1;
if self.vertex == 2 {
self.vertex = 0;
self.i += 2;
}
}
Stage::CornerRecords => {
let Some(face) = self.faces.get(self.i / 3).copied() else {
self.vertex_sort = true;
self.width = 1;
self.begin = 0;
self.out = 0;
self.stage = Stage::Sort;
return Ok(());
};
let coordinate = target_key(*face.p.get(self.i % 3).ok_or_else(|| invalid("CPU glass corner position"))?, face.medium, options)?;
*self.edges.get_mut(self.i).ok_or_else(|| invalid("CPU glass corner record"))? =
Edge { medium: face.medium, a: coordinate, b: [0; 3], face: self.i, forward: false };
self.i += 1;
}
Stage::VertexLinks => {
let Some(a) = self.edges.get(self.i).copied() else {
self.stage = Stage::Contact;
self.pair = (0, 1);
return Ok(());
};
if let Some(b) = self.i.checked_sub(1).and_then(|i| self.edges.get(i)).copied()
&& (a.medium, a.a) == (b.medium, b.a)
&& self.root(a.face)? != self.root(b.face)?
{
return Err(invalid(
"CPU glass vertex link must be one connected cycle or sheet boundary path; pinched or touching fans are unsupported",
));
}
self.i += 1;
}
Stage::Contact => {
let Some(a) = self.faces.get(self.pair.0).copied() else {
self.stage = Stage::Sources;
self.medium = 0;
self.triangle = 0;
self.vertex = 0;
return Ok(());
};
let Some(b) = self.faces.get(self.pair.1).copied() else {
self.next_pair();
return Ok(());
};
let ba = Triangle::new(a.p).map_err(super::image::error)?.bounds();
let bb = Triangle::new(b.p).map_err(super::image::error)?.bounds();
if !disjoint(ba, bb) && forbidden_contact(a.p, b.p, a.medium == b.medium) {
return Err(invalid("CPU glass boundaries intersect, touch, overlap or self-intersect"));
}
self.next_pair();
}
Stage::Sources => {
let Some(input) = options.dielectrics.get(self.medium) else {
self.stage = Stage::Volume;
self.medium = 0;
self.vertex = 0;
return Ok(());
};
let body = scene.meshes.get(input.body_index).ok_or_else(|| invalid("CPU glass source-contact body"))?;
let Some(indices) = body.mesh.triangles.get(self.triangle) else {
self.medium += 1;
self.triangle = 0;
self.vertex = 0;
return Ok(());
};
let mut p = [Vec3::ZERO; 3];
for (p, index) in p.iter_mut().zip(indices) {
*p = *body.mesh.positions.get(*index as usize).ok_or_else(|| invalid("CPU glass source-contact vertex"))?;
}
let areas = options.area_lights.as_ref().map_or(0, Vec::len);
if let Some(light) = options.area_lights.as_ref().and_then(|lights| lights.get(self.vertex)) {
let vector = |p: [f64; 3]| Vec3::new(p[0], p[1], p[2]);
let c = vector(light.center_mm);
let u = vector(light.edge_u_mm) * 0.5;
let v = vector(light.edge_v_mm) * 0.5;
let q = [c - u - v, c + u - v, c + u + v, c - u + v];
predicate_domain(&q)?;
if forbidden_contact(p, [q[0], q[1], q[2]], false) || forbidden_contact(p, [q[0], q[2], q[3]], false) {
return Err(invalid("CPU glass cannot touch an analytic area emitter"));
}
self.vertex += 1;
} else if let Some(light) =
self.vertex.checked_sub(areas).and_then(|at| options.punctual_lights.as_ref().and_then(|lights| lights.get(at)))
{
let q = Vec3::new(light.position_mm[0], light.position_mm[1], light.position_mm[2]);
predicate_domain(&[q])?;
if side(p, q) == 0.0 && in_triangle(p, q, projection(p)) {
return Err(invalid("CPU point or spot source lies on a glass boundary"));
}
self.vertex += 1;
} else {
self.triangle += 1;
self.vertex = 0;
}
}
Stage::Volume => {
let Some(input) = options.dielectrics.get(self.medium) else {
self.stage = Stage::Parents;
self.outer = 0;
self.inner = 1;
return Ok(());
};
let region = *self.regions.get(self.medium).ok_or_else(|| invalid("CPU exact glass volume region"))?;
if input.boundary == DielectricBoundary::ThinSheet {
self.medium += 1;
return Ok(());
}
if self.vertex == 0 {
self.i = region.begin;
self.volume = Default::default();
self.vertex = 1;
}
if self.i == region.end {
if !self.volume.positive() {
return Err(invalid("CPU glass must enclose positive exact outward-oriented volume"));
}
self.medium += 1;
self.vertex = 0;
return Ok(());
}
let p = self.faces.get(self.i).ok_or_else(|| invalid("CPU exact glass volume face"))?.p;
self.volume.add_term(p, self.vertex - 1)?;
self.vertex += 1;
if self.vertex == 7 {
self.vertex = 1;
self.i += 1;
}
}
Stage::Parents => {
if self.outer >= self.count {
self.finish();
return Ok(());
}
if self.inner >= self.count {
self.outer += 1;
self.inner = self.outer + 1;
return Ok(());
}
let a = self.regions[self.outer];
let b = self.regions[self.inner];
if disjoint(a.bounds, b.bounds) {
self.inner += 1;
return Ok(());
}
let oa = options.dielectrics.get(self.outer).ok_or_else(|| invalid("CPU glass outer options"))?;
let ob = options.dielectrics.get(self.inner).ok_or_else(|| invalid("CPU glass inner options"))?;
if oa.boundary == DielectricBoundary::ThinSheet || ob.boundary == DielectricBoundary::ThinSheet {
return Err(invalid("CPU thin sheets may not touch or overlap a closed medium's bounds"));
}
let (parent, child) = if contains(a.bounds, b.bounds) {
(self.outer, self.inner)
} else if contains(b.bounds, a.bounds) {
(self.inner, self.outer)
} else {
return Err(invalid("CPU glass overlapping bounds have no conservative nesting certificate"));
};
self.pair = (parent, child);
self.i = self.regions[parent].begin;
self.j = self.regions[parent].begin;
self.vertex = 0;
self.stage = Stage::Convex;
}
Stage::Convex | Stage::Inside => {
let (parent, child) = self.pair;
let pr = self.regions[parent];
let cr = self.regions[child];
let inside = matches!(self.stage, Stage::Inside);
let points = if inside { cr } else { pr };
if self.i >= pr.end {
if !inside {
self.stage = Stage::Inside;
self.i = pr.begin;
self.j = cr.begin;
self.vertex = 0;
return Ok(());
}
let old = self.regions[child].parent;
if old.is_none_or(|old| contains(self.regions[old].bounds, pr.bounds)) {
self.regions[child].parent = Some(parent);
}
self.inner += 1;
self.stage = Stage::Parents;
return Ok(());
}
let face = self.faces.get(self.i).ok_or_else(|| invalid("CPU glass nesting face"))?;
let p = self.faces.get(self.j).and_then(|f| f.p.get(self.vertex)).copied().ok_or_else(|| invalid("CPU glass nesting point"))?;
let sign = side(face.p, p);
if (inside && sign <= 0.0) || (!inside && sign < 0.0) {
return Err(invalid("CPU nested glass requires a convex outward parent and strictly contained child"));
}
self.vertex += 1;
if self.vertex == 3 {
self.vertex = 0;
self.j += 1;
}
if self.j >= points.end {
self.i += 1;
self.j = points.begin;
}
}
Stage::Done => return Err(invalid("CPU glass certification already complete")),
}
Ok(())
}
fn finish(&mut self) {
self.stage = Stage::Done;
self.faces = Vec::new();
self.edges = Vec::new();
self.scratch = Vec::new();
self.parents = Vec::new();
self.ranks = Vec::new();
}
}
fn disjoint(a: Bounds, b: Bounds) -> bool {
let a0 = a.min();
let a1 = a.max();
let b0 = b.min();
let b1 = b.max();
a1.x < b0.x || b1.x < a0.x || a1.y < b0.y || b1.y < a0.y || a1.z < b0.z || b1.z < a0.z
}
fn contains(a: Bounds, b: Bounds) -> bool {
let a0 = a.min();
let a1 = a.max();
let b0 = b.min();
let b1 = b.max();
a0.x <= b0.x && a0.y <= b0.y && a0.z <= b0.z && a1.x >= b1.x && a1.y >= b1.y && a1.z >= b1.z
}
/// Source-plane exclusion is limited to the producing body and the exact f64
/// plane, so a parallel opposite interface or another body's occluder remains.
pub(super) fn same_plane(a: [Vec3; 3], b: [Vec3; 3]) -> bool {
b.into_iter().all(|p| side(a, p) == 0.0)
}
/// Exact positive-X oriented crossing with half-open projected edge ownership.
/// Shared projected edges with equal normal signs contribute once; silhouettes
/// contribute opposite signs (or neither). Thus a closed oriented manifold has
/// winding0 outside and1 inside, including rays through edges/vertices. A point
/// actually on the surface is refused instead of assigned to an arbitrary side.
pub(super) fn origin_crossing(t: [Vec3; 3], origin: Vec3) -> job::Result<i8> {
predicate_domain(&[origin])?;
let sign = side(t, origin);
if sign == 0.0 && in_triangle(t, origin, projection(t)) {
return Err(invalid("CPU camera or pupil origin lies exactly on a Glass boundary"));
}
let mut q = t.map(|p| project(p, 0));
let p = project(origin, 0);
let area = orient2d(q[0], q[1], q[2]);
if area == 0.0 || sign == 0.0 || opposite(sign, area) {
return Ok(0);
}
let contribution = if area > 0.0 { 1 } else { -1 };
if area < 0.0 {
q.swap(1, 2);
}
for (a, b) in [(0, 1), (1, 2), (2, 0)] {
let a = q[a];
let b = q[b];
let edge = orient2d(a, b, p);
let owns = b.y > a.y || (b.y == a.y && b.x < a.x);
if edge < 0.0 || (edge == 0.0 && !owns) {
return Ok(0);
}
}
Ok(contribution)
}
/// Exact contact between a finite pre-clip segment and one optical triangle.
/// Touches, endpoints and coplanar stretches count: none is silently classified
/// as a constant medium. The existing camera's clipped projection is not changed.
pub(super) fn origin_segment_contact(t: [Vec3; 3], a: Vec3, b: Vec3) -> job::Result<bool> {
predicate_domain(&[a, b])?;
let sa = side(t, a);
let sb = side(t, b);
if (sa > 0.0 && sb > 0.0) || (sa < 0.0 && sb < 0.0) {
return Ok(false);
}
let drop = projection(t);
if (sa == 0.0 && in_triangle(t, a, drop)) || (sb == 0.0 && in_triangle(t, b, drop)) {
return Ok(true);
}
if opposite(sa, sb) {
let signs = [side([a, b, t[0]], t[1]), side([a, b, t[1]], t[2]), side([a, b, t[2]], t[0])];
return Ok(!signs.iter().any(|s| *s < 0.0) || !signs.iter().any(|s| *s > 0.0));
}
if sa == 0.0 && sb == 0.0 {
for (i, j) in [(0, 1), (1, 2), (2, 0)] {
if coplanar_edge_bad([[a, b], [t[i], t[j]]], [t, t], false, drop) {
return Ok(true);
}
}
}
Ok(false)
}
/// A scattered origin must not round back onto its producing/endpoint plane.
/// This conservative precision check uses the same exact predicate domain as
/// the certificate; it never nudges a point to manufacture an interior sample.
pub(super) fn origin_on_plane(triangle: [Vec3; 3], point: Vec3) -> job::Result<bool> {
predicate_domain(&triangle)?;
predicate_domain(&[point])?;
Ok(side(triangle, point) == 0.0)
}