Files
solidcraft/crates/engine/src/cosmetic_threads.rs
T
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

373 lines
16 KiB
Rust

//! Original schematic cylindrical hatching for evaluated cosmetic threads. The segments lie
//! on the displayed triangles, so neither a separate cylinder nor a helical B-rep is needed.
use solidcraft_geom::prelude::*;
use std::collections::HashMap;
use solidcore_record::Vec3;
use solidcraft_doc::{ModelBody, ThreadInfo};
use solidcraft_geom::Mesh;
/// Shared upper bound for cosmetic strokes in one viewport/snapshot scene.
pub const MAX_SCENE_SEGMENTS: usize = 65_536;
/// Shared scene limits, including unsuccessful inspections. Camera-only frames reuse the
/// viewport's existing scene cache; scene rebuilds cannot restart this budget for each body.
pub struct Budget {
work: usize,
strokes: usize,
}
impl Default for Budget {
fn default() -> Self {
Self { work: 500_000, strokes: MAX_SCENE_SEGMENTS }
}
}
impl Budget {
pub fn available(&self) -> bool {
self.work > 0 && self.strokes > 0
}
fn spend(&mut self, n: usize) -> bool {
if n > self.work {
self.work = 0;
return false;
}
self.work -= n;
self.strokes > 0
}
/// Bounded preflight before requesting a body's potentially refined display mesh.
pub fn has_thread(&mut self, name: &str, threads: &[ThreadInfo]) -> bool {
for t in threads {
if !self.spend(1) {
return false;
}
if t.body == name {
return true;
}
}
false
}
}
/// Depth-tested, section-clippable strokes. Use the same mesh as the visible surface to avoid
/// fighting a different tessellation. There are at most 32 bands and 32,768 segments per call.
/// This is a schematic marking, not a representation of the manufactured thread profile.
pub fn segments(body: &ModelBody, mesh: &Mesh, threads: &[ThreadInfo]) -> Vec<(Vec3, Vec3)> {
segments_with_budget(body, mesh, threads, &mut Budget::default())
}
/// Generate one body's strokes, charging all inspections and emitted segments to the scene.
pub fn segments_with_budget(body: &ModelBody, mesh: &Mesh, threads: &[ThreadInfo], budget: &mut Budget) -> Vec<(Vec3, Vec3)> {
let mut out = Vec::new();
// Spread a readable schematic density across ordinary assemblies before hitting a hard
// scene cap. A large set of fine-pitch threads need not consume the budget on its first
// few occurrences. This is deliberately independent of camera motion and scene caching.
let bands = (768.0 / threads.len().max(1) as f64).clamp(4.0, 32.0);
if body.body.is_mesh() {
return out;
}
for t in threads {
if !budget.spend(1) {
return out;
}
if t.body != body.name {
continue;
}
let length = t.end - t.start;
if !t.axis_point.is_finite()
|| !t.axis.is_finite()
|| !length.is_finite()
|| length <= 0.0
|| !t.start.is_finite()
|| !t.pitch.is_finite()
|| t.pitch <= 0.0
|| !t.major_diameter.is_finite()
|| t.major_diameter <= 0.0
|| !t.radius.is_finite()
|| t.radius <= 0.0
{
continue;
}
let seed = if t.axis.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };
let Some(u) = t.axis.cross(seed).normalized() else { continue };
let tilt = 0.18 * t.radius;
let spacing = t.pitch.max((length + 2.0 * tilt) / bands);
let tolerance = (t.radius * 1e-6).max(1e-7);
let mut faces = HashMap::new();
for (tri, face) in mesh.triangles.iter().zip(&mesh.tri_face) {
if !budget.spend(1) || out.len() >= 32_768 {
return out;
}
let matched = if let Some(found) = faces.get(face) {
*found
} else {
// face_surface traverses to `face`; charge that traversal too. No unbounded
// face collection or full-mesh scan occurs before the budget is checked.
if !budget.spend((*face as usize).saturating_add(1)) {
return out;
}
let surface = solidcraft_kernel::guard("cosmetic thread surface", || Ok(solidcraft_kernel::face_surface(&body.body, *face as usize)))
.ok()
.flatten();
let found = match surface {
Some(solidcraft_kernel::FaceSurface::Cylinder { origin, axis, radius }) => {
let offset = origin - t.axis_point;
axis.dot(t.axis).abs() > 1.0 - 1e-6
&& (offset - t.axis * offset.dot(t.axis)).len() < tolerance
&& (radius - t.radius).abs() < tolerance
}
_ => false,
};
faces.insert(*face, found);
found
};
if !matched {
continue;
}
let Some(points) = mesh.tri(tri) else { continue };
let [a, b, c] = points;
let center = (a + b + c) / 3.0 - t.axis_point;
let radial = center - t.axis * center.dot(t.axis);
// Mesh winding distinguishes a bore from a shaft without rescanning the entire
// mesh for every cylindrical face.
let inward = (b - a).cross(c - a).dot(radial) < 0.0;
if inward != t.internal {
continue;
}
// Tilt bands across the placed cylindrical wall. The world-axis seed can change
// their schematic orientation after rotation; it never changes their surface.
let phase = points.map(|p| {
let v = p - t.axis_point;
(v.dot(t.axis) - t.start + 0.18 * v.dot(u)) / spacing
});
// A long face can extend far beyond a short threaded interval. Restrict the
// candidate bands before the loop so its budget never hides that interval.
let lo = phase.into_iter().fold(f64::INFINITY, f64::min).max(-tilt / spacing).ceil();
let hi = phase.into_iter().fold(f64::NEG_INFINITY, f64::max).min((length + tilt) / spacing).floor();
if !lo.is_finite() || !hi.is_finite() || lo.abs() > 1e9 || hi.abs() > 1e9 {
continue;
}
for band in (lo as i64..=hi as i64).take(64) {
if !budget.spend(1) || out.len() >= 32_768 {
return out;
}
let mut hits = Vec::with_capacity(2);
for (i, j) in [(0, 1), (1, 2), (2, 0)] {
let (Some(&a), Some(&b), Some(&fa), Some(&fb)) = (points.get(i), points.get(j), phase.get(i), phase.get(j)) else { continue };
let level = band as f64;
if (fa <= level && fb > level) || (fb <= level && fa > level) {
hits.push(a + (b - a) * ((level - fa) / (fb - fa)));
}
}
if let [a, b] = hits.as_slice()
&& let Some(pair) = trim(*a, *b, t)
{
out.push(pair);
budget.strokes -= 1;
}
}
}
}
out
}
fn trim(a: Vec3, b: Vec3, t: &ThreadInfo) -> Option<(Vec3, Vec3)> {
let z = (a - t.axis_point).dot(t.axis);
let dz = (b - a).dot(t.axis);
let (mut lo, mut hi) = (0.0f64, 1.0f64);
if dz.abs() < 1e-12 {
if z < t.start || z > t.end {
return None;
}
} else {
let p = (t.start - z) / dz;
let q = (t.end - z) / dz;
lo = lo.max(p.min(q));
hi = hi.min(p.max(q));
}
(hi > lo).then(|| (a + (b - a) * lo, a + (b - a) * hi))
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
use crate::Session;
use serde_json::json;
fn run(s: &mut Session, command: &str, params: serde_json::Value) {
s.execute(command, &params).unwrap();
}
#[test]
fn modeled_threads_do_not_receive_cosmetic_strokes() {
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"radius":3,"height":4}));
let before = s.world_state().unwrap().bodies[0].mesh().triangles.len();
run(&mut s, "solid.thread", json!({"face":[3,0,3],"designation":"M6","length":2,"modeled":true}));
let st = s.world_state().unwrap();
assert!(st.threads.is_empty());
assert_ne!(st.bodies[0].mesh().triangles.len(), before);
assert!(segments(&st.bodies[0], &st.bodies[0].mesh(), &st.threads).is_empty());
}
#[test]
fn downstream_enlargement_is_not_mistaken_for_the_threaded_wall() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":10}));
run(&mut s, "solid.hole", json!({"position":[10,10,10],"direction":[0,0,-1],"thread":"M6"}));
run(&mut s, "solid.hole", json!({"position":[10,10,10],"direction":[0,0,-1],"diameter":8,"depth":3}));
let st = s.world_state().unwrap();
let body = &st.bodies[0];
let lines = segments(body, &body.mesh(), &st.threads);
assert!(!lines.is_empty());
for p in lines.iter().flat_map(|(a, b)| [a, b]) {
assert!(p.z <= 7.0 + 1e-6, "enlarged smooth wall must be unmarked: {p:?}");
}
}
#[test]
fn many_occurrences_have_matching_metadata_and_share_work_and_output_limits() {
let mut s = Session::default();
let c = s.execute("component.create", &json!({"name":"Pegs"})).unwrap();
run(&mut s, "solid.cylinder", json!({"radius":3,"height":20}));
run(&mut s, "solid.thread", json!({"face":[3,0,10],"designation":"M6"}));
for i in 1..96 {
run(&mut s, "occurrence.copy", json!({"component":c["component"],"translate":[i*8,0,0]}));
}
let st = s.world_state().unwrap();
assert_eq!(st.bodies.len(), 96);
assert_eq!(st.threads.len(), 96);
let started = std::time::Instant::now();
let mut budget = Budget::default();
let mut count = 0;
for b in &st.bodies {
assert!(st.threads.iter().any(|t| t.body == b.name));
assert!(!segments(b, &b.mesh(), &st.threads).is_empty(), "{}", b.name);
if budget.available() {
count += segments_with_budget(b, &b.mesh(), &st.threads, &mut budget).len();
}
}
eprintln!("96 occurrences: {count} strokes; {} work units left; {:?} including per-occurrence verification", budget.work, started.elapsed());
assert!(count > 1000 && count <= MAX_SCENE_SEGMENTS);
let mut stale = st.threads.clone();
for t in &mut stale {
t.radius *= 2.0;
}
let mut budget = Budget { work: 10_000, strokes: MAX_SCENE_SEGMENTS };
let mut seen = 0;
for b in st.bodies.iter().cycle().take(1000) {
if !budget.available() {
break;
}
assert!(segments_with_budget(b, &b.mesh(), &stale, &mut budget).is_empty());
seen += 1;
}
assert!(seen > 1);
assert_eq!(budget.work, 0);
assert_eq!(budget.strokes, MAX_SCENE_SEGMENTS);
}
#[test]
fn tapped_hole_marks_survive_reopen_and_rotated_occurrences() {
let mut s = Session::default();
// This fixture rotates its first component; new assemblies ground that part by default.
let c = s.execute("component.create", &json!({"name":"Plate","grounded":false})).unwrap();
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":10,"body_name":"PlateBody"}));
run(&mut s, "solid.hole", json!({"position":[10,10,10],"direction":[0,0,-1],"thread":"M6","depth":7}));
run(&mut s, "occurrence.move", json!({"occurrence":c["occurrence"],"translate":[30,20,10],"axis":[1,0,0],"angle":"90 deg","capture":true}));
let saved = s.doc.to_json();
let reopened = solidcraft_doc::Document::from_json(&saved).unwrap();
let mut s = Session::new(reopened);
let st = s.world_state().unwrap();
assert_eq!(st.threads.len(), 1);
assert!(st.threads[0].axis.z.abs() < 1e-6);
let body = &st.bodies[0];
let lines = segments(body, &body.mesh(), &st.threads);
assert!(lines.len() > 20);
let t = &st.threads[0];
for p in lines.iter().flat_map(|(a, b)| [a, b]) {
let z = (*p - t.axis_point).dot(t.axis);
assert!(z >= t.start - 1e-8 && z <= t.end + 1e-8);
}
let mut tiny = t.clone();
tiny.pitch = 1e-12;
assert!(segments(body, &body.mesh(), &[tiny]).len() <= 32_768);
s.execute("solid.thread", &json!({"face":[0,0,0],"designation":"bad"})).unwrap_err();
assert_eq!(s.doc.to_json(), saved);
}
#[test]
fn cosmetic_internal_and_external_marks_preserve_geometry_and_partial_extent() {
for internal in [false, true] {
let mut s = Session::default();
if internal {
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":10,"body_name":"Part"}));
run(&mut s, "solid.hole", json!({"position":[10,10,10],"diameter":5,"direction":[0,0,-1]}));
} else {
run(&mut s, "solid.cylinder", json!({"radius":3,"height":10,"body_name":"Part"}));
}
let before = s.world_state().unwrap().bodies[0].mesh();
let face = if internal { json!([12.5, 10, 9]) } else { json!([3, 0, 9]) };
run(&mut s, "solid.thread", json!({"face":face,"designation":"M6","length":4,"modeled":false}));
let st = s.world_state().unwrap();
let body = &st.bodies[0];
assert_eq!(before.positions, body.mesh().positions);
assert_eq!(before.triangles, body.mesh().triangles);
let saved = s.doc.to_json();
let lines = segments(body, &body.mesh(), &st.threads);
assert!(lines.len() > 20, "{internal}: {}", lines.len());
let t = &st.threads[0];
for p in lines.iter().flat_map(|(a, b)| [a, b]) {
let z = (*p - t.axis_point).dot(t.axis);
assert!(z >= t.start - 1e-8 && z <= t.end + 1e-8);
assert!(p.is_finite());
}
assert!(segments(body, &body.mesh(), &[]).is_empty());
for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
for field in 0..5 {
let mut hostile = t.clone();
match field {
0 => hostile.pitch = value,
1 => hostile.start = value,
2 => hostile.end = value,
3 => hostile.axis_point.x = value,
_ => hostile.radius = value,
}
assert!(segments(body, &body.mesh(), &[hostile]).is_empty());
}
}
assert_eq!(s.doc.to_json(), saved);
let scene = crate::view::scene(&s, &crate::render::Camera::default()).unwrap();
assert!(!scene.lines.iter().any(|l| l.width == 0.85), "ordinary snapshots preserve the default-off behavior");
for distance in [25.0, 60.0] {
let cam = crate::render::Camera {
target: if internal { Vec3::new(10., 10., 5.) } else { Vec3::new(0., 0., 5.) },
distance,
..Default::default()
};
for section in [None, Some((cam.target, Vec3::X))] {
let mut scene = crate::view::scene_with_thread_markings(
&s,
&cam,
section,
crate::view::world_curve_parts,
&crate::view::Palette::DEFAULT,
Default::default(),
true,
)
.unwrap();
assert!(scene.lines.iter().any(|l| l.width == 0.85 && !l.on_top));
let marked = crate::render::render(&scene, &cam, 320, 240).rgba;
scene.lines.retain(|l| l.width != 0.85);
let plain = crate::render::render(&scene, &cam, 320, 240).rgba;
let changed = marked.as_chunks::<4>().0.iter().zip(plain.as_chunks::<4>().0.iter()).filter(|(a, b)| a != b).count();
assert!(changed > 15, "internal={internal}, distance={distance}, section={section:?}: {changed}");
}
}
s.execute("edit.undo", &json!({})).unwrap();
assert!(s.world_state().unwrap().threads.is_empty());
}
}
}