Skip to content

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

9.1 KB
Raw Blame
//! One reusable prepaid primary-origin certificate. No camera sample, RNG, image
//! plane or scene mutation: one bounds/BVH/triangle/hierarchy operation per step.
use super::{
    Bounds, WorkBudget,
    bvh::{PrimitiveScan, ScanPoll},
    glass_mesh,
};
use crate::job::{self, CancelToken, DielectricBoundary, DielectricOptions};
use solidcore_record::Vec3;
use solidcraft_geom::prelude::*;
fn invalid(message: &str) -> job::JobError {
    job::JobError::new(job::ErrorCode::InvalidScene, message)
}
fn contains(b: Bounds, p: Vec3) -> bool {
    let lo = b.min();
    let hi = b.max();
    p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y && p.z >= lo.z && p.z <= hi.z
}
#[derive(Clone, Copy)]
enum Stage {
    Bounds,
    Faces,
    FaceResult,
    Preclip,
    PreclipScan,
    Order,
    Done,
}
pub(super) struct Task {
    origin: Vec3,
    near: Vec3,
    point: usize,
    medium: usize,
    winding: i32,
    bits: [u8; 2],
    stage: Stage,
    ordered: [usize; 8],
    occupied: u8,
    len: usize,
    cursor: Option<PrimitiveScan>,
}
impl Task {
    pub(super) fn required_bytes() -> u64 {
        std::mem::size_of::<Self>() as u64
    }
    /// Outward bounds are conservative. Existing outside rays pay no new work
    /// and allocate no classifier slot; actual ambiguous pupil samples decide.
    pub(super) fn required(certificate: &glass_mesh::Task, inputs: &[DielectricOptions], origin: Vec3, near: Vec3) -> job::Result<bool> {
        for (i, _) in inputs.iter().enumerate() {
            let b = certificate.region(i)?.bounds;
            let lo = origin.min(near);
            let hi = origin.max(near);
            let min = b.min();
            let max = b.max();
            if lo.x <= max.x && hi.x >= min.x && lo.y <= max.y && hi.y >= min.y && lo.z <= max.z && hi.z >= min.z {
                return Ok(true);
            }
        }
        Ok(false)
    }
    pub(super) fn new(origin: Vec3, near: Vec3) -> job::Result<Self> {
        if !super::bounded(origin) || !super::bounded(near) {
            return Err(invalid("CPU camera origin exceeds the bounded world envelope"));
        }
        Ok(Self {
            origin,
            near,
            point: 0,
            medium: 0,
            winding: 0,
            bits: [0; 2],
            stage: Stage::Bounds,
            ordered: [0; 8],
            occupied: 0,
            len: 0,
            cursor: None,
        })
    }
    pub(super) fn ready(&self) -> bool {
        matches!(self.stage, Stage::Done)
    }
    pub(super) fn result(&self) -> job::Result<([usize; 8], usize, Vec3)> {
        if !self.ready() {
            return Err(invalid("CPU camera medium certificate is incomplete"));
        }
        Ok((self.ordered, self.len, self.origin))
    }
    pub(super) fn step(
        &mut self,
        certificate: &glass_mesh::Task,
        inputs: &[DielectricOptions],
        scene: super::prepared::PreparedScene<'_>,
        work: &mut WorkBudget,
        cancel: &CancelToken,
    ) -> job::Result<()> {
        if matches!(self.stage, Stage::Faces | Stage::PreclipScan) {
            let poll = self
                .cursor
                .as_mut()
                .ok_or_else(|| invalid("CPU camera classification cursor missing"))?
                .step(scene.bvh, work, cancel)
                .map_err(super::image::error)?;
            match poll {
                ScanPoll::Pending => {}
                ScanPoll::Done => {
                    self.cursor = None;
                    self.stage = if matches!(self.stage, Stage::Faces) { Stage::FaceResult } else { Stage::Order };
                    self.medium = if matches!(self.stage, Stage::Order) { 0 } else { self.medium };
                }
                ScanPoll::Primitive(index) => {
                    let look = scene.primitives.get(index).ok_or_else(|| invalid("CPU camera classification primitive missing"))?;
                    if matches!(self.stage, Stage::Faces) {
                        let region = certificate.region(self.medium)?;
                        if (region.primitive_begin..region.primitive_end).contains(&index) {
                            let p = if self.point == 0 { self.origin } else { self.near };
                            self.winding = self
                                .winding
                                .checked_add(i32::from(glass_mesh::origin_crossing(look.vertices, p)?))
                                .ok_or_else(|| invalid("CPU camera winding overflow"))?;
                        }
                    } else if inputs.iter().any(|input| input.body_index == look.body_index)
                        && glass_mesh::origin_segment_contact(look.vertices, self.origin, self.near)?
                    {
                        return Err(invalid("CPU camera near clipping meets a Glass boundary; move the camera or pupil away from that boundary"));
                    }
                }
            }
            return Ok(());
        }
        work.tick(cancel).map_err(super::image::error)?;
        if inputs.len() > 8 {
            return Err(invalid("CPU camera classification exceeds eight media"));
        }
        match self.stage {
            Stage::Bounds => {
                let Some(input) = inputs.get(self.medium) else {
                    if self.point == 0 && self.origin != self.near {
                        self.point = 1;
                        self.medium = 0;
                        return Ok(());
                    }
                    if self.point == 0 {
                        self.bits[1] = self.bits[0];
                    }
                    if self.bits[0] != self.bits[1] {
                        return Err(invalid("CPU camera near clipping crosses a Glass boundary; move the camera or pupil away from that boundary"));
                    }
                    self.medium = 0;
                    self.stage = if self.origin == self.near { Stage::Order } else { Stage::Preclip };
                    return Ok(());
                };
                let region = certificate.region(self.medium)?;
                let p = if self.point == 0 { self.origin } else { self.near };
                if input.boundary == DielectricBoundary::ThinSheet || !contains(region.bounds, p) {
                    self.medium += 1;
                    return Ok(());
                }
                self.winding = 0;
                self.cursor = Some(PrimitiveScan::new(p, Vec3::new(region.bounds.max().x, p.y, p.z)).map_err(super::image::error)?);
                self.stage = Stage::Faces;
            }
            Stage::FaceResult => {
                if !(0..=1).contains(&self.winding) {
                    return Err(invalid("CPU camera winding disagrees with its certified closed manifold"));
                }
                if self.winding == 1 {
                    let bits = self.bits.get_mut(self.point).ok_or_else(|| invalid("CPU camera point cursor"))?;
                    *bits |= 1_u8 << self.medium;
                }
                self.medium += 1;
                self.stage = Stage::Bounds;
            }
            Stage::Preclip => {
                self.cursor = Some(PrimitiveScan::new(self.origin.min(self.near), self.origin.max(self.near)).map_err(super::image::error)?);
                self.stage = Stage::PreclipScan;
            }
            Stage::Order => {
                let Some(_) = inputs.get(self.medium) else {
                    if self.occupied.count_ones() as usize != self.len {
                        return Err(invalid("CPU camera medium hierarchy has a missing parent"));
                    }
                    self.stage = Stage::Done;
                    return Ok(());
                };
                if self.bits[0] & (1_u8 << self.medium) != 0 {
                    let mut parent = certificate.region(self.medium)?.parent;
                    let mut depth = 0;
                    for _ in 0..8 {
                        let Some(p) = parent else {
                            break;
                        };
                        if p >= inputs.len() || self.bits[0] & (1_u8 << p) == 0 {
                            return Err(invalid("CPU camera origin is not inside its certified medium parent"));
                        }
                        depth += 1;
                        parent = certificate.region(p)?.parent;
                    }
                    if parent.is_some() || depth >= 8 {
                        return Err(invalid("CPU camera medium hierarchy exceeds eight layers"));
                    }
                    let occupied = 1_u8 << depth;
                    if self.occupied & occupied != 0 {
                        return Err(invalid("CPU camera origin is inside unrelated optical regions"));
                    }
                    *self.ordered.get_mut(depth).ok_or_else(|| invalid("CPU camera ordered medium slot"))? = self.medium;
                    self.occupied |= occupied;
                    self.len = self.len.max(depth + 1);
                }
                self.medium += 1;
            }
            Stage::Done => return Err(invalid("CPU camera medium certificate already complete")),
            Stage::Faces | Stage::PreclipScan => return Err(invalid("CPU camera scan bypassed its charged continuation")),
        }
        Ok(())
    }
}