SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Display tessellation plans (4/4): one GPU dispatch for the scene, intersection edges by Newton (#806)
Irakli Kourtis587cf865b8cf
diff --git a/crates/geom/src/bspline.rs b/crates/geom/src/bspline.rsindex 252a695e39..8d36ae4033 100644--- a/crates/geom/src/bspline.rs+++ b/crates/geom/src/bspline.rs@@ -854,3 +854,122 @@ pub(crate) mod tests {assert_eq!(local_basis(&[], 0.5, Side::Right, 1), vec![0.0, 0.0]);}}++/// A non-rational B-spline curve whose control points have `N` coordinates: a point in space+/// together with other values that vary along it (an intersection curve with its parameters on+/// both surfaces).+#[derive(Clone, Debug, PartialEq)]+pub struct CurveN<const N: usize> {+ pub degree: usize,+ pub knots: Vec<f64>,+ pub ctrl: Vec<[f64; N]>,+}++impl<const N: usize> CurveN<N> {+ /// The curve of degree `degree` through `points` at the increasing parameters `params`+ /// (global interpolation, The NURBS Book A9.1: clamped, interior knots by averaging the+ /// parameters).+ pub fn interpolate(params: &[f64], points: &[[f64; N]], degree: usize) -> SplineResult<CurveN<N>> {+ let m = points.len();+ if params.len() != m || degree == 0 || degree > MAX_SPLINE_DEGREE || m <= degree {+ return invalid(format!("{m} points, {} parameters, degree {degree}", params.len()));+ }+ if m > MAX_KNOTS || params.windows(2).any(|w| !(w[1] > w[0])) || params.iter().any(|t| !t.is_finite()) {+ return invalid("the parameters must be finite and increasing");+ }+ let (first, last) = (params[0], params[m - 1]);+ let mut knots = vec![first; degree + 1];+ for j in 1..m - degree {+ knots.push(params[j..j + degree].iter().sum::<f64>() / degree as f64);+ }+ knots.extend(std::iter::repeat_n(last, degree + 1));+ // N · P = Q, dense with partial pivoting (the matrix is banded; m is small here).+ let mut a = vec![vec![0.0f64; m]; m];+ for (row, &t) in a.iter_mut().zip(params) {+ let span = crate::tess::span_of(&knots, degree, m, t);+ let Some(b) = crate::tess::basis_ders(&knots, span, degree, t) else { return invalid("basis") };+ for (x, n) in row.iter_mut().skip(span - degree).zip(&b[0][..=degree]) {+ *x = *n;+ }+ }+ let mut q: Vec<[f64; N]> = points.to_vec();+ for col in 0..m {+ let Some(piv) = (col..m).max_by(|&x, &y| a[x][col].abs().total_cmp(&a[y][col].abs())) else { return invalid("empty") };+ if !(a[piv][col].abs() > 1e-14) {+ return invalid("singular interpolation system");+ }+ a.swap(col, piv);+ q.swap(col, piv);+ let (pr, pq) = (a[col].clone(), q[col]);+ for r in col + 1..m {+ let f = a[r][col] / pr[col];+ if f != 0.0 {+ for (x, p) in a[r].iter_mut().zip(&pr).skip(col) {+ *x -= f * p;+ }+ for (x, p) in q[r].iter_mut().zip(pq) {+ *x -= f * p;+ }+ }+ }+ }+ let mut ctrl = vec![[0.0; N]; m];+ for r in (0..m).rev() {+ let mut v = q[r];+ for (c, x) in ctrl.iter().enumerate().skip(r + 1) {+ for (vi, xi) in v.iter_mut().zip(x) {+ *vi -= a[r][c] * xi;+ }+ }+ ctrl[r] = v.map(|x| x / a[r][r]);+ }+ if ctrl.iter().flatten().any(|x| !x.is_finite()) {+ return invalid("interpolation did not give finite control points");+ }+ Ok(CurveN { degree, knots, ctrl })+ }++ /// The point and first derivative at `t` (clamped to the curve's range).+ pub fn eval(&self, t: f64) -> Option<([f64; N], [f64; N])> {+ let (p, n) = (self.degree, self.ctrl.len());+ if n <= p || self.knots.len() != n + p + 1 || !t.is_finite() {+ return None;+ }+ let t = t.clamp(*self.knots.get(p)?, *self.knots.get(n)?);+ let span = crate::tess::span_of(&self.knots, p, n, t);+ let b = crate::tess::basis_ders(&self.knots, span, p, t)?;+ let (mut x, mut dx) = ([0.0; N], [0.0; N]);+ let ctrl = self.ctrl.get(span - p..=span)?;+ for ((c, n), dn) in ctrl.iter().zip(&b[0]).zip(&b[1]) {+ for ((xk, dk), ck) in x.iter_mut().zip(dx.iter_mut()).zip(c) {+ *xk += n * ck;+ *dk += dn * ck;+ }+ }+ Some((x, dx))+ }+}++#[cfg(test)]+mod curve_n_tests {+ use super::*;++ #[test]+ fn interpolates_its_points_and_their_slope() {+ // A helix with a fourth coordinate rising linearly: the cubic passes through every+ // point and follows the curve between them.+ let at = |t: f64| [t.cos(), t.sin(), 0.3 * t, 2.0 * t];+ let params: Vec<f64> = (0..=24).map(|k| f64::from(k) * 0.25).collect();+ let points: Vec<[f64; 4]> = params.iter().map(|&t| at(t)).collect();+ let Ok(c) = CurveN::interpolate(¶ms, &points, 3) else { panic!("interpolates") };+ for (t, p) in params.iter().zip(&points) {+ let Some((q, _)) = c.eval(*t) else { panic!("evaluates") };+ assert!(q.iter().zip(p).all(|(a, b)| (a - b).abs() < 1e-9), "{t}");+ }+ let Some((q, d)) = c.eval(2.6) else { panic!("evaluates") };+ let w = at(2.6);+ assert!(q.iter().zip(w).all(|(a, b)| (a - b).abs() < 1e-3), "{q:?} vs {w:?}");+ assert!((d[3] - 2.0).abs() < 1e-6 && (d[2] - 0.3).abs() < 1e-3, "{d:?}");+ assert!(CurveN::interpolate(&[0.0, 0.0, 1.0, 2.0], &points[..4], 3).is_err(), "repeated parameter");+ }+}diff --git a/crates/geom/src/tess.rs b/crates/geom/src/tess.rsindex 3bd91aae8a..94d23b9442 100644--- a/crates/geom/src/tess.rs+++ b/crates/geom/src/tess.rs@@ -19,7 +19,7 @@ pub const MAX_EVAL_KNOTS: usize = 1 << 12;/// Most control points in one evaluable surface.pub const MAX_EVAL_POINTS: usize = 1 << 18;/// Basis slots for the highest evaluable degree.-const W: usize = MAX_SPLINE_DEGREE + 1;+pub(crate) const W: usize = MAX_SPLINE_DEGREE + 1;/// A rational B-spline curve: homogeneous control points `[x·w, y·w, z·w, w]`. Outside its/// domain it continues as the polynomial of the end span (a line extends for ever).@@ -241,7 +241,7 @@ fn nurbs_derivs(degree: [usize; 2], knots: &[Vec<f64>; 2], count: [usize; 2], ct/// The knot span used at `t`: the last non-empty span starting at or before `t`, clamped to/// the valid spans `p ≤ k < n` so parameters just outside the domain extend the end spans.-fn span_of(knots: &[f64], p: usize, n: usize, t: f64) -> usize {+pub(crate) fn span_of(knots: &[f64], p: usize, n: usize, t: f64) -> usize {let mut k = p;for i in p..n {if let (Some(&a), Some(&b)) = (knots.get(i), knots.get(i + 1))@@ -259,7 +259,7 @@ fn span_of(knots: &[f64], p: usize, n: usize, t: f64) -> usize {/// Non-zero basis functions of degree `p` on span `span` and their first derivatives/// (NURBS Book A2.3 with n = 1). `ders[0][j]` is `N_{span−p+j}`, `ders[1][j]` its derivative.-fn basis_ders(knots: &[f64], span: usize, p: usize, t: f64) -> Option<[[f64; W]; 2]> {+pub(crate) fn basis_ders(knots: &[f64], span: usize, p: usize, t: f64) -> Option<[[f64; W]; 2]> {if p == 0 || p >= W {return None;}diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rsindex c723f08811..130c2b3544 100644--- a/crates/gpu/src/lib.rs+++ b/crates/gpu/src/lib.rs@@ -50,13 +50,22 @@ pub struct GpuMesh {pub indices: wgpu::Buffer,pub index_count: u32,pub vertex_count: u32,- /// Each vertex's face (the plan's face numbering), for colouring by face.+ /// Each vertex's face (its plan's face numbering), for colouring by face.pub vertex_face: Vec<u32>,+ /// Per plan (in the order given), its vertices and indices.+ pub parts: Vec<Part>,bind: wgpu::BindGroup,// The inputs, kept until the evaluation has run._inputs: [wgpu::Buffer; 4],}+/// One plan's share of a [`GpuMesh`]: its vertices and its entries in the index buffer.+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct Part {+ pub vertices: std::ops::Range<u32>,+ pub indices: std::ops::Range<u32>,+}+/// The compute pipeline, ready to evaluate plans on one device.pub struct TessGpu {adapter: String,@@ -144,7 +153,7 @@ impl TessGpu {/// and normals in f32, fixed edge nodes exact). Blocks until the GPU is done (native).#[cfg(not(target_arch = "wasm32"))]pub fn evaluate(&self, plan: &TessPlan) -> Result<Mesh> {- let packed = pack(plan)?;+ let packed = pack(&[plan])?;let mut mesh = Mesh::default();let mut base = 0usize;for chunk in packed.vertices.chunks(MAX_BATCH * VERTEX_WORDS) {@@ -186,9 +195,16 @@ impl TessGpu {/// [`TessGpu::record`]. Refused (so the caller draws its CPU mesh) for a plan with more than/// [`MAX_BATCH`] vertices or a face without an evaluable surface.pub fn prepare(&self, plan: &TessPlan) -> Result<GpuMesh> {- let packed = pack(plan)?;+ self.prepare_many(&[plan])+ }++ /// Like [`TessGpu::prepare`] for several plans at once: one upload, one buffer and one+ /// dispatch for all of them (a viewport's whole scene), each plan's vertices and triangles in+ /// [`GpuMesh::parts`]. Refused past [`MAX_BATCH`] vertices in all.+ pub fn prepare_many(&self, plans: &[&TessPlan]) -> Result<GpuMesh> {+ let packed = pack(plans)?;if packed.count > MAX_BATCH {- return Err(GpuError::Unsupported(format!("a plan of {} vertices on the GPU", packed.count)));+ return Err(GpuError::Unsupported(format!("{} vertices in one dispatch", packed.count)));}let d = &self.device;let count = word(packed.count)?;@@ -211,14 +227,19 @@ impl TessGpu {});let mut tri: Vec<u32> = Vec::new();let mut vertex_face = Vec::with_capacity(packed.count);+ let mut parts = Vec::with_capacity(plans.len());let mut offset = 0u32;- for f in &plan.faces {- let n = word(f.uv.len())?;- for t in f.triangles.iter().filter(|t| t.iter().all(|&i| i < n)) {- tri.extend([offset + t[0], offset + t[1], offset + t[2]]);+ for plan in plans {+ let (v0, i0) = (offset, word(tri.len())?);+ for f in &plan.faces {+ let n = word(f.uv.len())?;+ for t in f.triangles.iter().filter(|t| t.iter().all(|&i| i < n)) {+ tri.extend([offset + t[0], offset + t[1], offset + t[2]]);+ }+ vertex_face.extend(std::iter::repeat_n(f.face, f.uv.len()));+ offset += n;}- vertex_face.extend(std::iter::repeat_n(f.face, f.uv.len()));- offset += n;+ parts.push(Part { vertices: v0..offset, indices: i0..word(tri.len())? });}let indices = init("tess mesh indices", &words(&tri), wgpu::BufferUsages::INDEX);let bind = d.create_bind_group(&wgpu::BindGroupDescriptor {@@ -238,6 +259,7 @@ impl TessGpu {index_count: word(tri.len())?,vertex_count: count,vertex_face,+ parts,bind,_inputs: [params, surfaces, data, verts],})@@ -348,10 +370,12 @@ fn push_curve(data: &mut Vec<f32>, c: &EvalCurve) -> Result<(u32, u32)> {Ok((knots, ctrl))}-fn pack(plan: &TessPlan) -> Result<Packed> {- let mut surfaces = Vec::with_capacity(plan.surfaces.len() * SURFACE_WORDS);+/// Several plans as one: their surfaces one after another, each face's surface index offset by+/// the surfaces of the plans before it.+fn pack(plans: &[&TessPlan]) -> Result<Packed> {+ let mut surfaces = Vec::with_capacity(plans.iter().map(|p| p.surfaces.len()).sum::<usize>() * SURFACE_WORDS);let mut data: Vec<f32> = Vec::new();- for s in &plan.surfaces {+ for s in plans.iter().flat_map(|p| &p.surfaces) {let mut head = [0u32; SURFACE_WORDS];match s {EvalSurface::Plane { origin, du, dv } => {@@ -394,39 +418,44 @@ fn pack(plan: &TessPlan) -> Result<Packed> {}surfaces.extend(head);}- let mut vertices = Vec::with_capacity(plan.vertex_count() * VERTEX_WORDS);+ let mut vertices = Vec::with_capacity(plans.iter().map(|p| p.vertex_count()).sum::<usize>() * VERTEX_WORDS);#[cfg(not(target_arch = "wasm32"))]let mut fixed = Vec::new();let mut count = 0usize;- for f in &plan.faces {- let Some(surface) = f.surface else {- return Err(GpuError::Unsupported("a face without an evaluable surface".into()));- };- if surface as usize >= plan.surfaces.len() {- return Err(GpuError::Failed("surface index out of range".into()));- }- for (k, uv) in f.uv.iter().enumerate() {- let pinned = f.fixed.get(k).copied();- let flags = u32::from(f.flip) | if pinned.is_some() { 2 } else { 0 };- let p = pinned.unwrap_or(Vec3::ZERO);- vertices.extend([- (uv[0] as f32).to_bits(),- (uv[1] as f32).to_bits(),- surface,- flags,- (p.x as f32).to_bits(),- (p.y as f32).to_bits(),- (p.z as f32).to_bits(),- 0,- ]);- if let Some(p) = pinned {- #[cfg(not(target_arch = "wasm32"))]- fixed.push((count, p));- #[cfg(target_arch = "wasm32")]- let _ = p;+ let mut base = 0u32;+ for plan in plans {+ for f in &plan.faces {+ let Some(surface) = f.surface else {+ return Err(GpuError::Unsupported("a face without an evaluable surface".into()));+ };+ if surface as usize >= plan.surfaces.len() {+ return Err(GpuError::Failed("surface index out of range".into()));+ }+ let surface = base + surface;+ for (k, uv) in f.uv.iter().enumerate() {+ let pinned = f.fixed.get(k).copied();+ let flags = u32::from(f.flip) | if pinned.is_some() { 2 } else { 0 };+ let p = pinned.unwrap_or(Vec3::ZERO);+ vertices.extend([+ (uv[0] as f32).to_bits(),+ (uv[1] as f32).to_bits(),+ surface,+ flags,+ (p.x as f32).to_bits(),+ (p.y as f32).to_bits(),+ (p.z as f32).to_bits(),+ 0,+ ]);+ if let Some(p) = pinned {+ #[cfg(not(target_arch = "wasm32"))]+ fixed.push((count, p));+ #[cfg(target_arch = "wasm32")]+ let _ = p;+ }+ count += 1;}- count += 1;}+ base += word(plan.surfaces.len())?;}Ok(Packed {surfaces,diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rsindex 993c03d029..4254c0c7f8 100644--- a/crates/gpu/src/tests.rs+++ b/crates/gpu/src/tests.rs@@ -112,6 +112,43 @@ fn a_resident_mesh_matches_the_cpu() {}}+/// Several bodies in one buffer and one dispatch (a viewport's scene): each plan's part holds+/// exactly its own vertices and triangles, evaluated as the CPU evaluates that plan alone.+#[test]+fn a_scene_in_one_dispatch_matches_each_body_on_the_cpu() {+ let Some(gpu) = gpu() else { return };+ let plans: Vec<TessPlan> = bodies().iter().map(|(_, b)| ok(b.display_plan_angular(0.01, std::f64::consts::PI / 9.0))).collect();+ let refs: Vec<&TessPlan> = plans.iter().collect();+ let mesh = ok(gpu.prepare_many(&refs));+ assert_eq!(mesh.parts.len(), plans.len());+ let d = &gpu.device;+ let size = u64::from(mesh.vertex_count) * VERTEX_STRIDE;+ let dst = d.create_buffer(&wgpu::BufferDescriptor {+ label: Some("test read"),+ size,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let mut enc = d.create_command_encoder(&Default::default());+ gpu.record(&mut enc, &mesh);+ enc.copy_buffer_to_buffer(&mesh.vertices, 0, &dst, 0, size);+ gpu.queue.submit([enc.finish()]);+ let slice = dst.slice(..);+ slice.map_async(wgpu::MapMode::Read, |_| {});+ ok(d.poll(wgpu::PollType::wait_indefinitely()));+ let out: Vec<f32> = ok(slice.get_mapped_range()).as_chunks::<4>().0.iter().map(|b| f32::from_le_bytes(*b)).collect();+ for ((plan, part), (name, _)) in plans.iter().zip(&mesh.parts).zip(bodies()) {+ let cpu = plan.evaluate();+ assert_eq!((part.vertices.end - part.vertices.start) as usize, cpu.positions.len(), "{name}");+ assert_eq!((part.indices.end - part.indices.start) as usize, cpu.triangles.len() * 3, "{name}");+ for (k, p) in cpu.positions.iter().enumerate() {+ let i = part.vertices.start as usize + k;+ let q = Vec3::new(f64::from(out[8 * i]), f64::from(out[8 * i + 1]), f64::from(out[8 * i + 2]));+ assert!(q.dist(*p) < 20.0 * 1e-5, "{name}: vertex {k}");+ }+ }+}+/// Display meshing of a 400-hole plate (#303's benchmark): reference mesher, plan, CPU and GPU/// evaluation. `cargo test --release -p solidcraft-gpu bench_plate -- --ignored --nocapture`.#[test]diff --git a/crates/kernel/src/tess/edges.rs b/crates/kernel/src/tess/edges.rsindex 1955c7b6f3..11d620a871 100644--- a/crates/kernel/src/tess/edges.rs+++ b/crates/kernel/src/tess/edges.rs@@ -5,6 +5,8 @@ use solidcraft_geom::Vec3;use truck_meshalgo::prelude::*;use truck_modeling as mt;+use solidcraft_geom::tess::EvalSurface;+use super::size::Rules;use crate::body::from_p3;@@ -13,11 +15,33 @@ pub(crate) const MAX_EDGE_NODES: usize = 20_000;/// Deepest bisection of one edge segment.const MAX_DEPTH: u32 = 24;+/// An edge's nodes, from its absolute front to its absolute back.+pub(crate) struct Nodes {+ pub points: Vec<Vec3>,+ /// For an intersection edge: its two surfaces and, per node, both surfaces' parameters+ /// (u1, v1, u2, v2) where Newton placed the node (`None` where truck's evaluation did).+ pub on: Option<([EvalSurface; 2], Vec<Option<[f64; 4]>>)>,+}++impl Nodes {+ fn plain(points: Vec<Vec3>) -> Nodes {+ Nodes { points, on: None }+ }++ /// The parameters of each node on `surface`, where the edge knows them: `None` unless+ /// `surface` is one of the edge's two surfaces.+ pub(crate) fn params_on(&self, surface: &EvalSurface) -> Option<Vec<Option<[f64; 2]>>> {+ let (surfaces, params) = self.on.as_ref()?;+ let side = surfaces.iter().position(|s| s == surface)?;+ Some(params.iter().map(|q| q.map(|q| [q[2 * side], q[2 * side + 1]])).collect())+ }+}+/// Nodes of `edge` from its absolute front to its absolute back: every chord within the/// tolerance of the curve (checked at the quarter points, so an S-bend in one segment is not/// missed), at most `h` long, and within the rules' facet angle. The end nodes are the/// vertices' own points, so edges meeting at a vertex meet exactly.-pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Vec<Vec3> {+pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Nodes {let tol = rules.tol;let front = from_p3(edge.absolute_front().point());let back = from_p3(edge.absolute_back().point());@@ -32,29 +56,35 @@ pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Vec<Vec3> {if let Some(p) = pts.last_mut() {*p = back;}- return pts;+ return Nodes::plain(pts);}let (t0, t1) = curve.range_tuple();if !(t0.is_finite() && t1.is_finite() && t1 > t0) {- return vec![front, back];+ return Nodes::plain(vec![front, back]);}- // Our evaluator where the curve has a form it knows (no allocation per point); truck's- // for intersection curves.+ // Our evaluators: the curve's own form where it has one (no allocation per point); for an+ // intersection curve, Newton on both surfaces from seeded parameters (see `ssi`), which+ // also gives each node's parameters on both faces; truck's evaluation only where that does+ // not converge.let fast = super::surface::eval_curve(&curve);- let at = |t: f64| {- match &fast {- Some(c) => c.eval(t).map(|(p, _)| p),- None => Some(from_p3(curve.subs(t))),+ let ssi = if fast.is_none() { super::ssi::Intersection::new(&curve) } else { None };+ type Pt = (Vec3, Option<[f64; 4]>);+ let at = |t: f64| -> Option<Pt> {+ match (&fast, &ssi) {+ (Some(c), _) => c.eval(t).map(|(p, _)| (p, None)),+ (None, Some(ix)) => ix.eval(t).map(|(p, q)| (p, Some(q))).or_else(|| Some((from_p3(curve.subs(t)), None))),+ (None, None) => Some((from_p3(curve.subs(t)), None)),}- .filter(|p| p.is_finite())+ .filter(|(p, _)| p.is_finite())};+ let fallback = || Nodes::plain(vec![front, back]);// A closed curve's chord between its ends is empty: start it from a few segments. An open// one starts whole, so an arc the tolerance leaves flat stays one segment.let initial: u32 = if edge.absolute_front().id() == edge.absolute_back().id() { 4 } else { 1 };let t_at = |i: u32| t0 + (t1 - t0) * f64::from(i) / f64::from(initial);- let mut ends: Vec<Vec3> = Vec::with_capacity(initial as usize + 1);+ let mut ends: Vec<Pt> = Vec::with_capacity(initial as usize + 1);for i in 0..=initial {- let Some(p) = at(t_at(i)) else { return vec![front, back] };+ let Some(p) = at(t_at(i)) else { return fallback() };ends.push(p);}// Depth-first bisection, segment by segment, keeping the output ordered. Each segment@@ -63,16 +93,17 @@ pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Vec<Vec3> {struct Seg {a: f64,b: f64,- pa: Vec3,- pb: Vec3,- mid: Option<Vec3>,+ pa: Pt,+ pb: Pt,+ mid: Option<Pt>,depth: u32,}- let mut out: Vec<Vec3> = vec![front];+ let Some(&first) = ends.first() else { return fallback() };+ let mut out: Vec<Pt> = vec![(front, first.1)];let mut stack: Vec<Seg> = Vec::with_capacity(64);for i in (0..initial).rev() {- let (Some(pa), Some(pb)) = (<[Vec3]>::get(&ends, i as usize).copied(), <[Vec3]>::get(&ends, i as usize + 1).copied()) else {- return vec![front, back];+ let (Some(pa), Some(pb)) = (<[Pt]>::get(&ends, i as usize).copied(), <[Pt]>::get(&ends, i as usize + 1).copied()) else {+ return fallback();};stack.push(Seg { a: t_at(i), b: t_at(i + 1), pa, pb, mid: None, depth: 0 });}@@ -86,11 +117,11 @@ pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Vec<Vec3> {let (q1, q3) = (at(a + 0.25 * (b - a)), at(a + 0.75 * (b - a)));let done = sg.depth >= MAX_DEPTH || out.len() + stack.len() >= MAX_EDGE_NODES;let fine = || {- let sag = [q1, pm, q3].iter().flatten().map(|q| q.dist_to_segment(pa, pb)).fold(0.0, f64::max);- let short = !(pa.dist(pb) > h * (1.0 + 1e-9));+ let sag = [q1, pm, q3].iter().flatten().map(|q| q.0.dist_to_segment(pa.0, pb.0)).fold(0.0, f64::max);+ let short = !(pa.0.dist(pb.0) > h * (1.0 + 1e-9));// The two half chords of an arc turning θ differ by θ/2.let straight = match (rules.turn, pm) {- (Some(t), Some(q)) => !t.exceeds(2.0 * turn(q - pa, pb - q), sag),+ (Some(t), Some(q)) => !t.exceeds(2.0 * turn(q.0 - pa.0, pb.0 - q.0), sag),_ => true,};short && straight && sag <= tol@@ -104,12 +135,13 @@ pub(crate) fn sample_edge(edge: &mt::Edge, rules: &Rules, h: f64) -> Vec<Vec3> {}}if out.len() < 2 {- return vec![front, back];+ return fallback();}if let Some(p) = out.last_mut() {- *p = back;+ p.0 = back;}- out+ let on = ssi.map(|ix| (ix.surfaces().clone(), out.iter().map(|p| p.1).collect()));+ Nodes { points: out.into_iter().map(|p| p.0).collect(), on }}/// Angle (radians) between two directions; zero when either is empty.@@ -130,7 +162,7 @@ mod tests {let Ok(cyl) = crate::cylinder(Vec3::ZERO, Vec3::Z, 10.0, 5.0) else { panic!("cylinder") };for tol in [0.1, 0.01, 0.001] {for e in cyl.solid.edge_iter() {- let pts = sample_edge(&e, &Rules { tol, max_len: f64::INFINITY, turn: None }, f64::INFINITY);+ let pts = sample_edge(&e, &Rules { tol, max_len: f64::INFINITY, turn: None }, f64::INFINITY).points;assert!(pts.len() >= 2);assert_eq!(pts.first().copied(), Some(from_p3(e.absolute_front().point())));assert_eq!(pts.last().copied(), Some(from_p3(e.absolute_back().point())));@@ -152,7 +184,7 @@ mod tests {fn edges_are_split_to_the_side_length_and_turn() {let Ok(cyl) = crate::cylinder(Vec3::ZERO, Vec3::Z, 10.0, 5.0) else { panic!("cylinder") };for e in cyl.solid.edge_iter() {- let pts = sample_edge(&e, &Rules { tol: 1.0, max_len: f64::INFINITY, turn: None }, 1.2);+ let pts = sample_edge(&e, &Rules { tol: 1.0, max_len: f64::INFINITY, turn: None }, 1.2).points;for w in pts.windows(2) {assert!(w[0].dist(w[1]) <= 1.2 + 1e-9, "side {}", w[0].dist(w[1]));}@@ -173,8 +205,36 @@ mod tests {.solid.edge_iter().filter(|e| seen.insert(e.id()) && !matches!(e.curve(), mt::Curve::Line(_)))- .map(|e| sample_edge(&e, &thirty, f64::INFINITY).len() - 1)+ .map(|e| sample_edge(&e, &thirty, f64::INFINITY).points.len() - 1).sum();assert!(sides >= 24, "{sides}");}++ /// An intersection edge's nodes carry their parameters on both faces: each face on one of+ /// the edge's surfaces gets them, and the surface there is the node.+ #[test]+ fn intersection_nodes_carry_their_parameters_on_both_faces() {+ let Ok(pin) = crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 6.0) else { panic!("pin") };+ let Ok(cross) = crate::cylinder(Vec3::new(5.0, -1.0, 2.0), Vec3::Y, 1.0, 12.0) else { panic!("cross") };+ let Ok(Some(body)) = crate::boolean(&pin, &cross, crate::BoolOp::Cut) else { panic!("cut") };+ let rules = Rules { tol: 0.01, max_len: f64::INFINITY, turn: None };+ let surfaces: Vec<EvalSurface> = body.solid.face_iter().filter_map(|f| super::super::surface::eval_surface(&f.surface())).collect();+ let (mut edges, mut checked) = (0, 0);+ let mut seen = std::collections::HashSet::new();+ for e in body.solid.edge_iter().filter(|e| seen.insert(e.id()) && matches!(e.curve(), mt::Curve::IntersectionCurve(_))) {+ let n = sample_edge(&e, &rules, f64::INFINITY);+ let on: Vec<_> = surfaces.iter().filter_map(|s| n.params_on(s).map(|q| (s, q))).collect();+ assert_eq!(on.len(), 2, "both faces of an intersection edge know its parameters");+ edges += 1;+ for (s, q) in on {+ for (p, uv) in n.points.iter().zip(q).skip(1).take(n.points.len().saturating_sub(2)) {+ let Some(uv) = uv else { continue };+ let Some((at, _, _)) = s.derivs(uv[0], uv[1]) else { panic!("evaluates") };+ assert!(at.dist(*p) < 1e-7, "{at:?} vs {p:?}");+ checked += 1;+ }+ }+ }+ assert!(edges > 0 && checked > 20, "{edges} edges, {checked} nodes");+ }}diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rsindex 6516d4ee61..10e18f5aac 100644--- a/crates/kernel/src/tess/mod.rs+++ b/crates/kernel/src/tess/mod.rs@@ -21,6 +21,7 @@ pub(crate) mod coons;pub(crate) mod edges;pub(crate) mod grid;pub(crate) mod size;+pub(crate) mod ssi;pub(crate) mod surface;pub(crate) mod uv;@@ -83,13 +84,13 @@ pub(crate) fn plan(solid: &Solid, tol: f64, turn: Option<size::Turn>) -> Result<let sampled = crate::par::map("edge nodes", &jobs, solved >= PARALLEL_CURVES || edges.len() >= PARALLEL_EDGES, |(e, h)| {Ok(edges::sample_edge(e, &rules, *h))});- let mut nodes: HashMap<_, Vec<Vec3>> = HashMap::with_capacity(edges.len());- for (e, pts) in edges.iter().zip(sampled) {- nodes.insert(e.id(), pts?);+ let mut nodes: HashMap<_, edges::Nodes> = HashMap::with_capacity(edges.len());+ for (e, n) in edges.iter().zip(sampled) {+ nodes.insert(e.id(), n?);}relax_crowded_faces(&faces, &jobs, &rules, &mut nodes);let oriented = |e: &mt::Edge| -> Option<Vec<Vec3>> {- let mut pts = nodes.get(&e.id())?.clone();+ let mut pts = nodes.get(&e.id())?.points.clone();if !e.orientation() {pts.reverse();}@@ -102,21 +103,32 @@ pub(crate) fn plan(solid: &Solid, tol: f64, turn: Option<size::Turn>) -> Result<Some((Some(eval), Some(size))) => (eval.clone(), *size),_ => return Err(unsupported(format!("face {fi}: surface not evaluable"))),};- // Boundary nodes, loop by loop (each edge's last node is the next edge's first).+ // Boundary nodes, loop by loop (each edge's last node is the next edge's first), with+ // their parameters on this face where the edge knows them (an intersection edge on+ // this face's surface).let mut loops3: Vec<Vec<Vec3>> = Vec::new();+ let mut known: Vec<Vec<Option<[f64; 2]>>> = Vec::new();for wire in face.absolute_boundaries() {- let mut pts = Vec::new();+ let (mut pts, mut uvs) = (Vec::new(), Vec::new());for e in wire.edge_iter() {- let mut ep = oriented(e).ok_or_else(|| unsupported("edge without nodes"))?;+ let n = nodes.get(&e.id()).ok_or_else(|| unsupported("edge without nodes"))?;+ let (mut ep, mut eq) = (n.points.clone(), n.params_on(&eval).unwrap_or_else(|| vec![None; n.points.len()]));+ if !e.orientation() {+ ep.reverse();+ eq.reverse();+ }ep.pop();+ eq.pop();pts.extend(ep);+ uvs.extend(eq);}if pts.len() >= 2 {loops3.push(pts);+ known.push(uvs);}}let mut stats = PlanStats::default();- let fp = plan_face(fi, &eval, &loops3, &rules, size, &mut stats)?;+ let fp = plan_face(fi, &eval, &loops3, &known, &rules, size, &mut stats)?;let fp = FacePlan {flip: !face.orientation(),triangles: if face.orientation() { fp.triangles } else { fp.triangles.into_iter().map(|[a, b, c]| [a, c, b]).collect() },@@ -146,7 +158,7 @@ pub(crate) fn plan(solid: &Solid, tol: f64, turn: Option<size::Turn>) -> Result</// holes is not worth a hundred times the work to draw each hole round). An edge keeps one set/// of nodes for both its faces, at the coarser of their levels, so every rim of a crowded face/// gets the same share whatever the order of the faces.-fn relax_crowded_faces(faces: &[&mt::Face], jobs: &[(&mt::Edge, f64)], rules: &size::Rules, nodes: &mut HashMap<mt::EdgeID, Vec<Vec3>>) {+fn relax_crowded_faces(faces: &[&mt::Face], jobs: &[(&mt::Edge, f64)], rules: &size::Rules, nodes: &mut HashMap<mt::EdgeID, edges::Nodes>) {use truck_meshalgo::tessellation::Deflection;let Some(turn) = rules.turn else { return };let h_of: HashMap<mt::EdgeID, (&mt::Edge, f64)> = jobs.iter().map(|(e, h)| (e.id(), (*e, *h))).collect();@@ -154,7 +166,7 @@ fn relax_crowded_faces(faces: &[&mt::Face], jobs: &[(&mt::Edge, f64)], rules: &sfaces.iter().map(|f| f.absolute_boundaries().iter().flat_map(|w| w.edge_iter().map(|e| e.id())).collect()).collect();let mut level: HashMap<mt::EdgeID, u8> = HashMap::new();for l in 1..=Deflection::MAX_RELAX {- let segments = |id: &mt::EdgeID| nodes.get(id).map_or(0, |n| n.len().saturating_sub(1));+ let segments = |id: &mt::EdgeID| nodes.get(id).map_or(0, |n| n.points.len().saturating_sub(1));let mut crowded: Vec<mt::EdgeID> = boundaries.iter().filter(|ids| ids.iter().map(segments).sum::<usize>() > Deflection::MAX_ANGLE_BOUNDARY)@@ -184,6 +196,7 @@ fn plan_face(fi: usize,s: &EvalSurface,loops3: &[Vec<Vec3>],+ known: &[Vec<Option<[f64; 2]>>],rules: &size::Rules,size: (f64, [f64; 2]),stats: &mut PlanStats,@@ -197,11 +210,17 @@ fn plan_face(let mut fixed: Vec<Vec3> = Vec::new();let mut uvs: Vec<[f64; 2]> = Vec::new();let mut ranges: Vec<std::ops::Range<usize>> = Vec::new();- for pts in loops3 {+ for (li, pts) in loops3.iter().enumerate() {let mut luv: Vec<[f64; 2]> = Vec::with_capacity(pts.len());let mut prev: Option<[f64; 2]> = None;- for p in pts {- let mut q = uv::project(s, &dom, *p, prev, accept).ok_or_else(|| fail("boundary does not lie on the surface"))?;+ for (k, p) in pts.iter().enumerate() {+ // Known parameters (an intersection edge's), else a projection seeded by the+ // previous node.+ let given = known.get(li).and_then(|l| l.get(k)).copied().flatten();+ let mut q = match given {+ Some(q) => q,+ None => uv::project(s, &dom, *p, prev, accept).ok_or_else(|| fail("boundary does not lie on the surface"))?,+ };if let Some(pr) = prev {for d in 0..2 {q[d] = uv::unwrap(q[d], pr[d], dom.period[d]);diff --git a/crates/kernel/src/tess/ssi.rs b/crates/kernel/src/tess/ssi.rsnew file mode 100644index 0000000000..c69a36c58e--- /dev/null+++ b/crates/kernel/src/tess/ssi.rs@@ -0,0 +1,219 @@+//! Points on a surface–surface intersection edge, on our own surface evaluators.+//!+//! truck stores an intersection edge as a leader curve (a polyline or B-spline near the+//! intersection) and its two surfaces, and finds each point by projecting the leader point onto+//! each surface in turn from no starting guess: a nearest-point search per surface per point.+//! Here the intersection is solved exactly at a set of leader parameters, and a cubic B-spline+//! is fitted through those points together with both surfaces' parameters there (a smooth+//! leader with its curves on both surfaces). Each point is then refined from the B-spline by+//! Newton's method on the four unknowns (u1, v1, u2, v2): S1(u1, v1) = S2(u2, v2), held on the+//! plane through the B-spline point normal to the B-spline (Barnhill & Kersey, "A marching+//! method for parametric surface/surface intersection", CAGD 7, 1990; Patrikalakis & Maekawa,+//! "Shape Interrogation for CAD/CAM", 2002, ch. 5). Every point is independent once seeded. Where the surfaces are close to+//! tangent along the edge (the system becomes singular) or Newton does not converge, the caller+//! uses truck's evaluation.++use solidcraft_geom::Vec3;+use solidcraft_geom::bspline::CurveN;+use solidcraft_geom::tess::EvalSurface;+use truck_meshalgo::prelude::*;+use truck_modeling as mt;++use super::uv::{self, Domain};+use crate::body::from_p3;++/// Leader parameters at which both surfaces' parameters are found up front.+const SEEDS: usize = 32;+/// Newton iterations per point (two or three suffice from a seed).+const MAX_ITER: usize = 8;+/// Below this sine of the angle between the surface normals the intersection is treated as+/// near-tangent: points there are left to truck.+const MIN_SIN: f64 = 0.05;++/// An intersection edge ready for point evaluation.+pub(crate) struct Intersection {+ surfaces: [EvalSurface; 2],+ domains: [Domain; 2],+ /// The smooth leader over the curve's parameter: the intersection point (x, y, z) and both+ /// surfaces' parameters (u1, v1, u2, v2), periodic directions unwrapped along it.+ leader: CurveN<7>,+ /// Convergence tolerance (mm).+ eps: f64,+}++impl Intersection {+ /// `None` unless `curve` is an intersection curve whose surfaces have evaluators and whose+ /// leader projects onto both.+ pub(crate) fn new(curve: &mt::Curve) -> Option<Self> {+ let mt::Curve::IntersectionCurve(ic) = curve else { return None };+ let surfaces = [super::surface::eval_surface(ic.surface0())?, super::surface::eval_surface(ic.surface1())?];+ let domains = [uv::domain(&surfaces[0]), uv::domain(&surfaces[1])];+ let (t0, t1) = curve.range_tuple();+ if !(t0.is_finite() && t1.is_finite() && t1 > t0) {+ return None;+ }+ let leader = |t: f64| match ic.leader() {+ mt::Leader::Polyline(l) => (from_p3(l.subs(t)), from_v3(l.der(t))),+ mt::Leader::BSpline(l) => (from_p3(l.subs(t)), from_v3(l.der(t))),+ };+ // The leader lies within the curve's tolerance of both surfaces.+ let accept = (ic.tolerance() * 100.0).max(1e-6);+ let scale = (0..=SEEDS).map(|k| leader(t0 + (t1 - t0) * k as f64 / SEEDS as f64).0.len()).fold(1.0, f64::max);+ let mut it = Intersection { surfaces, domains, leader: CurveN { degree: 1, knots: Vec::new(), ctrl: Vec::new() }, eps: scale * 1e-10 };+ let (mut params, mut points) = (Vec::with_capacity(SEEDS + 1), Vec::with_capacity(SEEDS + 1));+ let mut prev: Option<[f64; 4]> = None;+ for k in 0..=SEEDS {+ let t = t0 + (t1 - t0) * k as f64 / SEEDS as f64;+ let (p, d) = leader(t);+ let mut q = [0.0; 4];+ for (i, (s, dom)) in it.surfaces.iter().zip(&it.domains).enumerate() {+ let hint = prev.map(|w| [w[2 * i], w[2 * i + 1]]);+ let mut uv = uv::project(s, dom, p, hint, accept)?;+ if let Some(h) = hint {+ for d in 0..2 {+ uv[d] = uv::unwrap(uv[d], h[d], dom.period[d]);+ }+ }+ q[2 * i] = uv[0];+ q[2 * i + 1] = uv[1];+ }+ // Exactly on the intersection where Newton converges (near-tangent seeds keep the+ // leader point and its projections).+ let (p, q) = d.normalized().and_then(|dir| it.newton(p, dir, q)).unwrap_or((p, q));+ params.push(t);+ points.push([p.x, p.y, p.z, q[0], q[1], q[2], q[3]]);+ prev = Some(q);+ }+ it.leader = CurveN::interpolate(¶ms, &points, 3).ok()?;+ Some(it)+ }++ /// The point at curve parameter `t` and both surfaces' parameters there, or `None`+ /// (near-tangent, or Newton failed).+ pub(crate) fn eval(&self, t: f64) -> Option<(Vec3, [f64; 4])> {+ let (x, dx) = self.leader.eval(t)?;+ let dir = Vec3::new(dx[0], dx[1], dx[2]).normalized()?;+ self.newton(Vec3::new(x[0], x[1], x[2]), dir, [x[3], x[4], x[5], x[6]])+ }++ /// The two surfaces, in the order of the parameters [`Intersection::eval`] gives.+ pub(crate) fn surfaces(&self) -> &[EvalSurface; 2] {+ &self.surfaces+ }++ /// Newton from the parameters `x` on S1 = S2, held on the plane through `l` normal to `dir`:+ /// the point and its parameters, or `None` (near-tangent, singular, or not converged).+ fn newton(&self, l: Vec3, dir: Vec3, mut x: [f64; 4]) -> Option<(Vec3, [f64; 4])> {+ for _ in 0..MAX_ITER {+ let (Some((p1, u1, v1)), Some((p2, u2, v2))) = (self.surfaces[0].derivs(x[0], x[1]), self.surfaces[1].derivs(x[2], x[3])) else {+ return None;+ };+ let gap = p1 - p2;+ let plane = dir.dot(p1 - l);+ let n = u1.cross(v1).normalized()?.cross(u2.cross(v2).normalized()?);+ if n.len() < MIN_SIN {+ return None;+ }+ if gap.len() <= self.eps && plane.abs() <= self.eps {+ return Some(((p1 + p2) * 0.5, x));+ }+ // J · dx = −F, F = (S1 − S2, dir · (S1 − L)).+ let j = [[u1.x, v1.x, -u2.x, -v2.x], [u1.y, v1.y, -u2.y, -v2.y], [u1.z, v1.z, -u2.z, -v2.z], [dir.dot(u1), dir.dot(v1), 0.0, 0.0]];+ let dx = solve4(j, [-gap.x, -gap.y, -gap.z, -plane])?;+ for (xi, d) in x.iter_mut().zip(dx) {+ *xi += d;+ }+ for i in 0..2 {+ let [u, v] = self.domains[i].clamp([x[2 * i], x[2 * i + 1]]);+ x[2 * i] = u;+ x[2 * i + 1] = v;+ }+ }+ None+ }+}++fn from_v3(v: mt::Vector3) -> Vec3 {+ Vec3::new(v.x, v.y, v.z)+}++/// `a · x = b` for a 4 × 4 system by Gaussian elimination with partial pivoting; `None` when+/// singular.+fn solve4(mut a: [[f64; 4]; 4], mut b: [f64; 4]) -> Option<[f64; 4]> {+ let scale = a.iter().flatten().fold(0.0f64, |m, x| m.max(x.abs()));+ if !(scale > 0.0) {+ return None;+ }+ for c in 0..4 {+ let p = (c..4).max_by(|&i, &j| a[i][c].abs().total_cmp(&a[j][c].abs()))?;+ if !(a[p][c].abs() > 1e-12 * scale) {+ return None;+ }+ a.swap(c, p);+ b.swap(c, p);+ let pivot = a[c];+ for r in c + 1..4 {+ let f = a[r][c] / pivot[c];+ for (x, p) in a[r].iter_mut().zip(pivot).skip(c) {+ *x -= f * p;+ }+ b[r] -= f * b[c];+ }+ }+ let mut x = [0.0; 4];+ for c in (0..4).rev() {+ let s: f64 = (c + 1..4).map(|k| a[c][k] * x[k]).sum();+ x[c] = (b[c] - s) / a[c][c];+ }+ x.iter().all(|v| v.is_finite()).then_some(x)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn solves_a_four_by_four_system() {+ let a = [[2.0, 1.0, 0.0, 0.0], [1.0, 3.0, 1.0, 0.0], [0.0, 1.0, 4.0, 1.0], [0.0, 0.0, 1.0, 5.0]];+ let x = [1.0, -2.0, 0.5, 3.0];+ let b = [0, 1, 2, 3].map(|r| (0..4).map(|c| a[r][c] * x[c]).sum::<f64>());+ let Some(got) = solve4(a, b) else { panic!("solves") };+ for (g, w) in got.iter().zip(x) {+ assert!((g - w).abs() < 1e-12);+ }+ assert!(solve4([[1.0; 4]; 4], [1.0; 4]).is_none(), "singular");+ }++ /// Points on the intersection edges of a boolean (a cross hole: two cylinders) lie on both+ /// surfaces, on truck's curve (the parameterisation follows our smooth leader, so the same+ /// parameter may sit at a slightly different place along it), and advance along the curve.+ #[test]+ fn intersection_points_lie_on_both_surfaces_and_on_truck_s_curve() {+ let Ok(pin) = crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 6.0) else { panic!("pin") };+ let Ok(cross) = crate::cylinder(Vec3::new(5.0, -1.0, 2.0), Vec3::Y, 1.0, 12.0) else { panic!("cross") };+ let Ok(Some(body)) = crate::boolean(&pin, &cross, crate::BoolOp::Cut) else { panic!("cut") };+ let mut checked = 0;+ for e in body.solid.edge_iter() {+ let curve = e.curve();+ let Some(ix) = Intersection::new(&curve) else { continue };+ let (t0, t1) = curve.range_tuple();+ let dense: Vec<Vec3> = (0..=1000).map(|k| from_p3(curve.subs(t0 + (t1 - t0) * f64::from(k) / 1000.0))).collect();+ let near = |p: Vec3| dense.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::MAX, f64::min);+ let mut last: Option<Vec3> = None;+ for k in 0..=50 {+ let t = t0 + (t1 - t0) * f64::from(k) / 50.0;+ let Some((p, _)) = ix.eval(t) else { continue };+ for (s, dom) in ix.surfaces.iter().zip(&ix.domains) {+ assert!(uv::project(s, dom, p, None, 1e-8).is_some(), "t {t}: {p:?} off a surface");+ }+ assert!(near(p) < 1e-4, "t {t}: {p:?} is {} from truck's curve", near(p));+ if let Some(q) = last {+ assert!(p.dist(q) > 0.0, "t {t}: the points advance");+ }+ last = Some(p);+ checked += 1;+ }+ }+ assert!(checked > 100, "{checked} points checked");+ }+}diff --git a/crates/kernel/src/tess/uv.rs b/crates/kernel/src/tess/uv.rsindex b495aeddbc..4e15853f3a 100644--- a/crates/kernel/src/tess/uv.rs+++ b/crates/kernel/src/tess/uv.rs@@ -33,7 +33,7 @@ pub(crate) fn domain(s: &EvalSurface) -> Domain {}impl Domain {- fn clamp(&self, uv: [f64; 2]) -> [f64; 2] {+ pub(crate) fn clamp(&self, uv: [f64; 2]) -> [f64; 2] {let mut out = uv;for (d, x) in out.iter_mut().enumerate() {if let (Some((a, b)), None) = (self.range[d], self.period[d]) {diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex b605e6efec..75b64842cc 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -184,7 +184,7 @@ struct Batch {count: u32,}-/// A planned body on the GPU: its evaluated mesh and a colour per vertex.+/// A chunk of planned bodies on the GPU: their evaluated mesh and a colour per vertex.struct PlannedDraw {mesh: Arc<solidcraft_gpu::GpuMesh>,colors: wgpu::Buffer,@@ -206,9 +206,9 @@ struct Batches {xray: Option<Batch>,under: Option<Batch>,planned: Vec<PlannedDraw>,- /// Evaluated plans by the plan's address, holding the plan so the address stays its own:- /// a body whose plan is unchanged is not evaluated again when the scene is rebuilt.- resident: std::collections::HashMap<usize, (Arc<solidcraft_engine::geom::tess::TessPlan>, Arc<solidcraft_gpu::GpuMesh>)>,+ /// Evaluated chunks by their plans' addresses, holding the plans so the addresses stay+ /// theirs: a chunk whose plans are unchanged is not evaluated again when the scene is rebuilt.+ resident: std::collections::HashMap<Vec<usize>, (Vec<Arc<solidcraft_engine::geom::tess::TessPlan>>, Arc<solidcraft_gpu::GpuMesh>)>,}impl Batches {@@ -238,6 +238,9 @@ impl Batches {}}+ /// The planned bodies on the GPU: in chunks of at most `MAX_BATCH` vertices (one for any+ /// ordinary scene), each uploaded and evaluated in one dispatch and drawn in one call. A+ /// chunk whose plans are unchanged is not evaluated again; colours are rebuilt each time.fn planned(&mut self,device: &wgpu::Device,@@ -245,27 +248,47 @@ impl Batches {encoder: &mut wgpu::CommandEncoder,bodies: &[PlannedBody],) -> Vec<PlannedDraw> {- let ptr = |b: &PlannedBody| Arc::as_ptr(&b.plan) as usize;- self.resident.retain(|k, _| bodies.iter().any(|b| ptr(b) == *k));- let mut out = Vec::with_capacity(bodies.len());+ let mut chunks: Vec<Vec<&PlannedBody>> = Vec::new();+ let mut filled = 0usize;for b in bodies {- let mesh = match self.resident.get(&ptr(b)) {+ let n = b.plan.vertex_count();+ match chunks.last_mut() {+ Some(c) if filled + n <= solidcraft_gpu::MAX_BATCH => c.push(b),+ _ => {+ chunks.push(vec![b]);+ filled = 0;+ }+ }+ filled += n;+ }+ let key = |c: &[&PlannedBody]| c.iter().map(|b| Arc::as_ptr(&b.plan) as usize).collect::<Vec<usize>>();+ self.resident.retain(|k, _| chunks.iter().any(|c| key(c) == *k));+ let mut out = Vec::with_capacity(chunks.len());+ for chunk in &chunks {+ let mesh = match self.resident.get(&key(chunk)) {Some((_, m)) => m.clone(),- None => match tess.prepare(&b.plan) {- Ok(m) => {- tess.record(encoder, &m);- let m = Arc::new(m);- self.resident.insert(ptr(b), (b.plan.clone(), m.clone()));- m- }- Err(e) => {- log::warn!("a body is not drawn on the GPU: {e}");- continue;+ None => {+ let plans: Vec<&solidcraft_engine::geom::tess::TessPlan> = chunk.iter().map(|b| &*b.plan).collect();+ match tess.prepare_many(&plans) {+ Ok(m) => {+ tess.record(encoder, &m);+ let m = Arc::new(m);+ self.resident.insert(key(chunk), (chunk.iter().map(|b| b.plan.clone()).collect(), m.clone()));+ m+ }+ Err(e) => {+ log::warn!("bodies are not drawn on the GPU: {e}");+ continue;+ }}- },+ }};- let last = b.face_colors.last().copied().unwrap_or([200, 200, 200, 255]);- let bytes: Vec<u8> = mesh.vertex_face.iter().flat_map(|f| b.face_colors.get(*f as usize).copied().unwrap_or(last)).collect();+ let mut bytes = Vec::with_capacity(mesh.vertex_face.len() * 4);+ for (part, b) in mesh.parts.iter().zip(chunk) {+ let last = b.face_colors.last().copied().unwrap_or([200, 200, 200, 255]);+ let faces = mesh.vertex_face.get(part.vertices.start as usize..part.vertices.end as usize).unwrap_or_default();+ bytes.extend(faces.iter().flat_map(|f| b.face_colors.get(*f as usize).copied().unwrap_or(last)));+ }if let Some(colors) = upload(device, "sc_planned_colors", &bytes, 4) {out.push(PlannedDraw { mesh, colors: colors.buffer });}