diff --git a/crates/kernel/src/tess/edges.rs b/crates/kernel/src/tess/edges.rs index ccbbd999d..789b0342b 100644 --- a/crates/kernel/src/tess/edges.rs +++ b/crates/kernel/src/tess/edges.rs @@ -16,6 +16,9 @@ const MAX_DEPTH: u32 = 24; /// An edge's nodes, from its start vertex (interval min) to its end vertex (interval max). pub(crate) struct Nodes { pub points: Vec, + /// The curve's parameter at each node (the edge's interval, ends included): where each + /// face's pcurve of the edge gives the node's (u, v). + pub params: Vec, } /// Nodes of edge `ei` of `b` from its start to its end: every chord within the tolerance of @@ -32,6 +35,10 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R }; let (front, back) = (vertex(0)?, vertex(1)?); let tol = rules.tol; + let [t0, t1] = edge.interval; + if !(t0.is_finite() && t1.is_finite() && t1 > t0) { + return Err(fail(format!("interval [{t0}, {t1}]"))); + } if matches!(edge.curve, Curve::Line { .. }) { // Evenly, as few segments as keep each at most `h`. The ends are the vertices' own // points: `front + (back − front) · 1` is not `back` to the last bit, and the face that @@ -39,14 +46,12 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R // forwards takes the next edge's first node (the vertex) — a crack. let n = if h > 0.0 { (front.dist(back) / h).ceil().clamp(1.0, (MAX_EDGE_NODES - 1) as f64) as usize } else { 1 }; let mut pts: Vec = (0..=n).map(|i| front + (back - front) * (i as f64 / n as f64)).collect(); - if let Some(p) = pts.last_mut() { + let mut params: Vec = (0..=n).map(|i| t0 + (t1 - t0) * (i as f64 / n as f64)).collect(); + if let (Some(p), Some(t)) = (pts.last_mut(), params.last_mut()) { *p = back; + *t = t1; } - return Ok(Nodes { points: pts }); - } - let [t0, t1] = edge.interval; - if !(t0.is_finite() && t1.is_finite() && t1 > t0) { - return Err(fail(format!("interval [{t0}, {t1}]"))); + return Ok(Nodes { points: pts, params }); } let curve = CurveEval::new(&edge.curve).map_err(|e| fail(e.to_string()))?; let at = @@ -67,7 +72,7 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R mid: Option, depth: u32, } - let mut out: Vec = vec![front]; + let mut out: Vec<(f64, Vec3)> = vec![(t0, front)]; let mut stack: Vec = Vec::with_capacity(64); for (i, w) in ends.windows(2).enumerate().rev() { let (Some(&pa), Some(&pb)) = (w.first(), w.get(1)) else { continue }; @@ -94,13 +99,13 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R stack.push(Seg { a: m, b, pa: pm, pb, mid: Some(q3), depth: sg.depth + 1 }); stack.push(Seg { a, b: m, pa, pb: pm, mid: Some(q1), depth: sg.depth + 1 }); } else { - out.push(pb); + out.push((b, pb)); } } if let Some(p) = out.last_mut() { - *p = back; + *p = (t1, back); } - Ok(Nodes { points: out }) + Ok(Nodes { points: out.iter().map(|p| p.1).collect(), params: out.iter().map(|p| p.0).collect() }) } /// Angle (radians) between two directions; zero when either is empty. diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rs index 7d06bded3..1fd684444 100644 --- a/crates/kernel/src/tess/mod.rs +++ b/crates/kernel/src/tess/mod.rs @@ -1,6 +1,8 @@ //! SolidCraft's mesher: each face of a schema 4 record ([`brep::Brep`]) triangulated in its own //! parameters, with every edge sampled once so neighbouring faces share their boundary points -//! exactly, handed over as a [`TessPlan`] for the CPU or GPU evaluator. +//! exactly, handed over as a [`TessPlan`] for the CPU or GPU evaluator. A boundary node's +//! parameters on each face come from that face's exact pcurve of the edge, at the node's curve +//! parameter: nothing is projected, and a seam's two sides are its two pcurves. //! //! Per face: //! 1. a cheaper layout where the face suits one: planar faces whose boundary runs along their @@ -12,15 +14,15 @@ //! with interior seeds and Ruppert refinement, every node then evaluated on the exact //! surface (and refined where a triangle sags off it); //! 3. a face even that refuses (its loops cross or do not close in (u, v), or wind round a -//! seam or pole) is an error naming the face and why. Its cause is upstream, in the face's -//! boundary or parameters, and is fixed there; there is no other mesher to fall back to. +//! seam or pole), or whose pcurves do not lie on its edges, is an error naming the face (and +//! the edge) and why. Its cause is upstream, in the record's pcurves or seams, and is fixed +//! there; there is no other mesher to fall back to. pub(crate) mod cdt; pub(crate) mod collar; pub(crate) mod coons; pub(crate) mod cutgrid; pub(crate) mod edges; -pub(crate) mod fallback; pub(crate) mod grid; pub(crate) mod motorcycle; pub(crate) mod pieces; @@ -44,8 +46,6 @@ pub struct PlanStats { pub planar: usize, pub structured: usize, pub delaunay: usize, - /// Faces no method could plan, filled flat from their boundary nodes. - pub filled: usize, } /// Curved faces from which their sizes are worked out on the worker pool. @@ -64,15 +64,6 @@ const PARALLEL_EDGES: usize = 256; const MAX_LINES: usize = 8192; /// Most points Ruppert refinement may add to one face, beyond its seeds. const MAX_REFINE: usize = 20_000; -/// Two boundary nodes this close together on the surface (mm) are one node. Far below any -/// spacing a mesh can carry, and far above the parameters a projection tells apart. See -/// [`drop_collapsed`]. -const SAME_NODE: f64 = 1e-6; -/// How far a face's boundary may lie off its surface and still be planned on it, as a fraction of -/// the body's extent, at every display quality (ten chord tolerances at Normal). -const ON_SURFACE: f64 = 1e-2; -/// How much finer a refused face's edges are divided, retry by retry. -const REFINE_STEPS: [f64; 2] = [3.0, 10.0]; fn unsupported(what: impl std::fmt::Display) -> KernelError { KernelError::Failed(format!("not supported yet: tessellation: {what}")) @@ -141,11 +132,12 @@ pub(crate) fn plan(b: &brep::Brep, tol: f64, turn: Option) -> Result // its faces; faces then read their nodes. A planar face costs microseconds and a curved // one about a hundred, so the pool is used only where curved faces (or intersection // curves) make up the work. - let evals: Vec = faces + let evals: Vec<(EvalSurface, surface::Params)> = faces .iter() .enumerate() .map(|(fi, f)| surface::eval_surface(&f.surface, f.domain).map_err(|e| unsupported(format!("face {fi} ({}): {e}", kind(&f.surface))))) .collect::>()?; + let (evals, params): (Vec, Vec) = evals.into_iter().unzip(); let curved = evals.iter().filter(|e| !matches!(e, EvalSurface::Plane { .. })).count(); let sizes: Vec<(f64, [f64; 2])> = crate::par::map("face sizes", &evals, curved >= PARALLEL_SIZES, |s| Ok(size::face_size(s, &uv::domain(s), &rules))) @@ -163,46 +155,12 @@ pub(crate) fn plan(b: &brep::Brep, tol: f64, turn: Option) -> Result relax_crowded_faces(b, &jobs, &rules, &mut nodes)?; let indexed: Vec = (0..faces.len()).collect(); let planned = crate::par::map("face tessellation", &indexed, curved >= PARALLEL_FACES, |&fi| { - let (Some(face), Some(eval), Some(size)) = (faces.get(fi), evals.get(fi), sizes.get(fi)) else { + let (Some(face), Some(eval), Some(map), Some(size)) = (faces.get(fi), evals.get(fi), params.get(fi), sizes.get(fi)) else { return Err(unsupported(format!("face {fi}: missing"))); }; - // Boundary nodes, loop by loop (each edge's last node is the next edge's first). A - // vertex loop (a pole) bounds no area and has no nodes of its own. - let mut loops3: Vec> = Vec::new(); - for l in &face.loops { - let Loop::Edges { edges } = l else { continue }; - let mut pts = Vec::new(); - for oe in edges { - let n = nodes.get(oe.edge as usize).ok_or_else(|| unsupported(format!("face {fi}: edge {} without nodes", oe.edge)))?; - let mut ep = n.points.clone(); - if !oe.forward { - ep.reverse(); - } - ep.pop(); - pts.extend(ep); - } - if pts.len() >= 2 { - loops3.push(pts); - } - } - Ok((loops3, known)) - }; - // A plan in the surface's orientation turned the face's way. - let oriented_face = |face: &mt::Face, fp: FacePlan| FacePlan { - flip: !face.orientation(), - triangles: if face.orientation() { fp.triangles } else { fp.triangles.into_iter().map(|[a, b, c]| [a, c, b]).collect() }, - ..fp - }; - let surface_of = |fi: usize| match sized.get(fi) { - Some((Some(eval), Some(size))) => Ok((eval.clone(), *size)), - _ => Err(unsupported(format!("face {fi}: surface not evaluable"))), - }; - // One face, from the edge nodes as they are and with the rules for its level of detail. - let plan_one = |fi: usize, face: &mt::Face, nodes: &HashMap, rules: &size::Rules| { - let (eval, size) = surface_of(fi)?; - let (loops3, known) = boundary(face, &eval, nodes)?; + let loops = boundary(b, fi, face, eval, map, &nodes, &rules)?; let mut stats = PlanStats::default(); - let fp = plan_face(fi, kind(&face.surface), eval, &loops3, &rules, *size, &mut stats)?; + let fp = plan_face(fi, kind(&face.surface), eval, &loops, &rules, *size, &mut stats)?; let fwd = forward.get(fi).copied().unwrap_or(true); let fp = FacePlan { flip: !fwd, triangles: if fwd { fp.triangles } else { fp.triangles.into_iter().map(|[a, b, c]| [a, c, b]).collect() }, ..fp }; @@ -218,13 +176,83 @@ pub(crate) fn plan(b: &brep::Brep, tol: f64, turn: Option) -> Result stats.planar += s.planar; stats.structured += s.structured; stats.delaunay += s.delaunay; - stats.filled += s.filled; } plan.edges = nodes.into_iter().map(|n| n.points).collect(); plan.edge_faces = edge_faces.into_iter().map(|fs| fs.into_iter().map(|f| u32::try_from(f).unwrap_or(u32::MAX)).collect()).collect(); Ok((plan, stats)) } +/// Face `fi`'s boundary, loop by loop: the shared edge nodes (each edge's last node is the next +/// edge's first) and their parameters on the face's surface, from each edge use's exact pcurve +/// at the node's curve parameter. A seam edge's two uses on one face have their own pcurves, so +/// its two sides are told apart. Each loop is unwrapped along its periodic directions (a pcurve +/// may start a period along from where the previous one ended). A vertex loop (a pole) bounds no +/// area and has no nodes of its own. A pcurve that does not cover its edge's interval, or puts a +/// node farther off the edge than the tolerances allow, is an error naming the face and edge: +/// the record is wrong there. +fn boundary( + b: &brep::Brep, + fi: usize, + face: &brep::Face, + s: &EvalSurface, + map: &surface::Params, + nodes: &[edges::Nodes], + rules: &size::Rules, +) -> Result> { + let dom = uv::domain(s); + let fail = |e: u32, why: String| unsupported(format!("face {fi} ({}): edge {e}: {why}", kind(&face.surface))); + let mut loops = Vec::with_capacity(face.loops.len()); + for l in &face.loops { + let Loop::Edges { edges } = l else { continue }; + let (mut pts, mut uvs): (Vec, Vec<[f64; 2]>) = (Vec::new(), Vec::new()); + for oe in edges { + let n = nodes.get(oe.edge as usize).ok_or_else(|| fail(oe.edge, "no nodes".into()))?; + let edge = b.edges.get(oe.edge as usize).ok_or_else(|| fail(oe.edge, "no such edge".into()))?; + let [t0, t1] = edge.interval; + let [p0, p1] = oe.pcurve.interval().ok_or_else(|| fail(oe.edge, "a malformed pcurve".into()))?; + let slack = 1e-9 * (t1 - t0).abs().max(t0.abs()).max(t1.abs()).max(1.0); + if (p0 - t0).abs() > slack || (p1 - t1).abs() > slack { + return Err(fail(oe.edge, format!("its pcurve spans [{p0}, {p1}], the edge [{t0}, {t1}]"))); + } + // The edge's own tolerance: how far its curve may stand off the face. + let accept = (rules.tol * 10.0).max(1e-6) + edge.tolerance.max(0.0); + let mut ep: Vec = n.points.clone(); + let mut eq: Vec<[f64; 2]> = Vec::with_capacity(ep.len()); + for (k, (t, p)) in n.params.iter().zip(&n.points).enumerate() { + let q = oe.pcurve.eval(t.clamp(p0, p1)).ok_or_else(|| fail(oe.edge, format!("its pcurve does not evaluate at t = {t}")))?; + let q = map.to_eval(q); + let on = + s.derivs(q[0], q[1]).map(|d| d.0).ok_or_else(|| fail(oe.edge, format!("node {k}: the surface does not evaluate at {q:?}")))?; + if !(on.dist(*p) <= accept) { + return Err(fail(oe.edge, format!("node {k}: its pcurve is {} mm off the edge at t = {t}", on.dist(*p)))); + } + eq.push(q); + } + if !oe.forward { + ep.reverse(); + eq.reverse(); + } + ep.pop(); + eq.pop(); + pts.extend(ep); + uvs.extend(eq); + } + let mut prev: Option<[f64; 2]> = None; + for q in &mut uvs { + if let Some(pr) = prev { + for d in 0..2 { + q[d] = uv::unwrap(q[d], pr[d], dom.period[d]); + } + } + prev = Some(*q); + } + if pts.len() >= 2 { + loops.push(seam::Loop { uv: uvs, pts }); + } + } + Ok(loops) +} + /// Bounded work for the facet angle: a face whose boundary would get more than /// [`size::MAX_ANGLE_BOUNDARY`] segments has its curved edges sampled again at twice the angle, /// as often as it takes, down to the tolerance alone (a plate with a thousand small holes is @@ -413,7 +441,7 @@ fn plan_face( fi: usize, kind: &str, s: &EvalSurface, - loops3: &[Vec], + loops: &[seam::Loop], rules: &size::Rules, size: (f64, [f64; 2]), stats: &mut PlanStats, @@ -421,35 +449,8 @@ fn plan_face( let tol = rules.tol; let (h, speed) = size; let dom = uv::domain(s); - let accept = (tol * 10.0).max(1e-6); let fail = |why: &str| unsupported(format!("face {fi} ({kind}): {why}")); - // Project every loop, unwrapping periodic parameters along it. - let mut projected: Vec = Vec::with_capacity(loops3.len()); - 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 (k, p) in pts.iter().enumerate() { - // A projection seeded by the previous node. - let mut q = uv::project(s, &dom, *p, prev, accept) - .ok_or_else(|| fail(&format!("boundary node {k} of loop {li} at {p:?} 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]); - } - } - luv.push(q); - prev = Some(q); - } - let mut l = seam::Loop { uv: luv, pts: pts.clone() }; - drop_collapsed(&mut l, speed); - for (d, per) in dom.period.iter().enumerate() { - if let Some(per) = per { - seam::close_through_pole(s, &mut l, d, *per); - } - } - projected.push(l); - } - align_periods(&mut projected, &dom); + let mut projected: Vec = loops.to_vec(); // A loop that winds around a periodic direction does not close in (u, v): the face is cut // along a parameter line into one period (a seamless cylinder face, a helical trim). // A loop that runs up a seam from a pole and straight back down it (a half sphere bounded @@ -511,7 +512,7 @@ fn plan_face( } ranges.push(start..uvs.len()); } - if uvs.len() < MIN_BOUNDARY_NODES { + if uvs.len() < 3 { return Err(fail("degenerate boundary")); } let mut bbox = [(f64::MAX, f64::MIN); 2]; @@ -529,7 +530,7 @@ fn plan_face( let seeds = cdt::lattice(bbox, step, &polys, speed); let eval = |u: f64, v: f64| s.derivs(u, v).map(|(p, su, sv)| (p, su.cross(sv).normalized())); let sag = cdt::Sag { eval: &eval, tol, h, turn: rules.turn, scale: speed }; - let fill = cdt::Fill { seeds: &seeds, refine: Some((sag, MAX_REFINE)), shape: !matches!(s, EvalSurface::Plane { .. }), lenient: false }; + let fill = cdt::Fill { seeds: &seeds, refine: Some((sag, MAX_REFINE)), shape: !matches!(s, EvalSurface::Plane { .. }) }; cdt::triangulate(&uvs, &ranges, fill).ok_or_else(|| fail("boundary crosses itself")) }; // Planar and curved faces alike: a structured grid where the boundary runs along the @@ -766,7 +767,7 @@ fn plan_pieces(f: &Region) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> { let seeds = cdt::lattice(bbox, [f.h / f.speed[0], f.h / f.speed[1]], &polys, f.speed); let eval = |u: f64, v: f64| s.derivs(u, v).map(|(p, su, sv)| (p, su.cross(sv).normalized())); let sag = cdt::Sag { eval: &eval, tol: f.rules.tol, h: f.h, turn: f.rules.turn, scale: f.speed }; - cdt::triangulate(&luv, &ranges, cdt::Fill { seeds: &seeds, refine: Some((sag, MAX_REFINE)), shape: true, lenient: false }) + cdt::triangulate(&luv, &ranges, cdt::Fill { seeds: &seeds, refine: Some((sag, MAX_REFINE)), shape: true }) })?; let (lextra, ltris) = local; let base = u32::try_from(n + extra.len()).ok()?; diff --git a/crates/kernel/src/tess/surface.rs b/crates/kernel/src/tess/surface.rs index 35eb5ef4f..67b5daa68 100644 --- a/crates/kernel/src/tess/surface.rs +++ b/crates/kernel/src/tess/surface.rs @@ -1,10 +1,11 @@ //! Surface records ([`brep::Surface`]) in the evaluator's form ([`EvalSurface`]), which the -//! planner and the CPU and GPU evaluators share. Planes, splines and revolutions keep their -//! own parameters ([`SurfaceEval`] holds them in that form already). A cylinder, cone, sphere -//! or torus is the revolution it is, exactly: its generator (a line, or a circle as an exact -//! rational arc) turned about its axis, the angle as the revolution's parameter. The planner -//! finds a boundary's parameters by projecting its nodes, so the generator's own parameter -//! need not be the record's height or latitude. +//! planner and the CPU and GPU evaluators share, and the map from the record's (u, v) to the +//! evaluator's, so a face's boundary takes its parameters from its edges' exact pcurves. +//! Planes, splines and revolutions keep their own parameters ([`SurfaceEval`] holds them in +//! that form already). A cylinder, cone, sphere or torus is the revolution it is, exactly: its +//! generator (a line, or a circle as an exact rational arc) turned about its axis by the +//! record's angle u; the generator's parameter is −v on a line and, on an arc, the rational +//! parameter of the record's angle v (closed form, [`Arc::param`]). use solidcraft_geom::Vec3; use solidcraft_geom::brep::eval::SurfaceEval; @@ -20,10 +21,59 @@ fn v3(p: [f64; 3]) -> Vec3 { /// No transform: the revolution as it is. const IDENTITY: [[f64; 4]; 3] = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]; -/// `surface` in the evaluator's form. `domain` is the face's parameter box in the record's -/// parameters, `[[u0, u1], [v0, v1]]`: a cylinder's or cone's generator spans the face's -/// heights (an unbounded line has no parameter box to project into). -pub(crate) fn eval_surface(surface: &brep::Surface, domain: [[f64; 2]; 2]) -> Result { +/// How a face's record parameters become its evaluator's. +#[derive(Clone, Copy, Debug, PartialEq)] +pub(crate) enum Params { + /// The same parameters (planes, splines, revolutions). + Same, + /// A cylinder or cone: (angle, height) to (−height, angle). + Height, + /// A sphere or torus: (angle, meridian angle) to (the reversed arc's parameter, angle). + Meridian(Arc), +} + +impl Params { + /// The evaluator's parameters of the record's `uv`. + pub(crate) fn to_eval(&self, uv: [f64; 2]) -> [f64; 2] { + let [u, v] = uv; + match self { + Params::Same => uv, + Params::Height => [-v, u], + Params::Meridian(a) => [1.0 - a.param(v), u], + } + } +} + +/// The spans of a circular arc made by [`arc`]: from angle `start`, `count` spans of `step` +/// each, over the parameter [0, 1]; `periodic` for a whole turn. +#[derive(Clone, Copy, Debug, PartialEq)] +pub(crate) struct Arc { + start: f64, + step: f64, + count: usize, + periodic: bool, +} + +impl Arc { + /// The arc's parameter at `angle`. On a rational quadratic span of half angle α with middle + /// weight cos α, tan(θ / 2) runs linearly from −tan(α / 2) to tan(α / 2) with the span's + /// own parameter (θ from the span's middle). A whole turn continues by whole parameters. + pub(crate) fn param(&self, angle: f64) -> f64 { + let total = self.step * self.count as f64; + let turns = if self.periodic { ((angle - self.start) / total).floor() } else { 0.0 }; + let a = angle - turns * total; + let i = (((a - self.start) / self.step).floor().max(0.0) as usize).min(self.count.saturating_sub(1)); + let half = 0.5 * self.step; + let local = a - (self.start + (i as f64 + 0.5) * self.step); + let s = 0.5 * ((0.5 * local).tan() / (0.5 * half).tan() + 1.0); + (i as f64 + s) / self.count as f64 + turns + } +} + +/// `surface` in the evaluator's form, and how the record's parameters map onto it. `domain` is +/// the face's parameter box in the record's parameters, `[[u0, u1], [v0, v1]]`: a cylinder's +/// or cone's generator spans the face's heights. +pub(crate) fn eval_surface(surface: &brep::Surface, domain: [[f64; 2]; 2]) -> Result<(EvalSurface, Params)> { use std::f64::consts::{FRAC_PI_2, TAU}; let invalid = |what: &str| KernelError::Invalid(format!("tessellation: {what}")); let axes = |f: &Frame| { @@ -45,27 +95,32 @@ pub(crate) fn eval_surface(surface: &brep::Surface, domain: [[f64; 2]; 2]) -> Re // Parameter −v: the generator at t is the surface at height −t. Ok(EvalCurve { degree: 1, knots: vec![-h1, -h1, -h0, -h0], ctrl: vec![[a.x, a.y, a.z, 1.0], [b.x, b.y, b.z, 1.0]] }) }; + // A meridian from the record's least angle to its greatest, reversed (so the normal is the + // record's natural one, outward). + let meridian = |centre: Vec3, x: Vec3, z: Vec3, r: f64, angle: [f64; 2], o: Vec3| -> Result<(EvalSurface, Params)> { + let (curve, spans) = arc(centre, x, z, r, angle); + Ok((revolved(curve.reversed(), o, z)?, Params::Meridian(spans))) + }; match surface { brep::Surface::Cylinder { frame, radius } => { let (o, x, z) = axes(frame); - revolved(generator(&|h| o + x * *radius + z * h)?, o, z) + Ok((revolved(generator(&|h| o + x * *radius + z * h)?, o, z)?, Params::Height)) } brep::Surface::Cone { frame, radius_at_origin, half_angle } => { let (o, x, z) = axes(frame); let slope = half_angle.tan(); - revolved(generator(&|h| o + x * (radius_at_origin + h * slope) + z * h)?, o, z) + Ok((revolved(generator(&|h| o + x * (radius_at_origin + h * slope) + z * h)?, o, z)?, Params::Height)) } brep::Surface::Sphere { frame, radius } => { let (o, x, z) = axes(frame); - // The meridian from the north pole to the south pole. - revolved(arc(o, x, z, *radius, [-FRAC_PI_2, FRAC_PI_2]).reversed(), o, z) + meridian(o, x, z, *radius, [-FRAC_PI_2, FRAC_PI_2], o) } brep::Surface::Torus { frame, major_radius, minor_radius } => { let (o, x, z) = axes(frame); - revolved(arc(o + x * *major_radius, x, z, *minor_radius, [0.0, TAU]).reversed(), o, z) + meridian(o + x * *major_radius, x, z, *minor_radius, [0.0, TAU], o) } _ => match SurfaceEval::new(surface) { - Ok(SurfaceEval::Eval(e, _)) => Ok(e), + Ok(SurfaceEval::Eval(e, _)) => Ok((e, Params::Same)), Ok(_) => Err(invalid("an analytic surface out of place")), Err(e) => Err(KernelError::Failed(format!("not supported yet: tessellation: {e}"))), }, @@ -73,8 +128,8 @@ pub(crate) fn eval_surface(surface: &brep::Surface, domain: [[f64; 2]; 2]) -> Re } /// The circle `centre + r (cos t x + sin t y)` for t in `angle`, as an exact rational quadratic -/// spline over [0, 1], one span per quarter turn or less. -fn arc(centre: Vec3, x: Vec3, y: Vec3, r: f64, angle: [f64; 2]) -> EvalCurve { +/// spline over [0, 1], one span per quarter turn or less, and its spans. +fn arc(centre: Vec3, x: Vec3, y: Vec3, r: f64, angle: [f64; 2]) -> (EvalCurve, Arc) { let span = angle[1] - angle[0]; let count = (span / std::f64::consts::FRAC_PI_2).ceil().clamp(1.0, 4.0) as usize; let step = span / count as f64; @@ -93,7 +148,8 @@ fn arc(centre: Vec3, x: Vec3, y: Vec3, r: f64, angle: [f64; 2]) -> EvalCurve { ctrl.push(at(start + step, 1.0, 1.0)); knots.extend(std::iter::repeat_n((i + 1) as f64 / count as f64, if i + 1 == count { 3 } else { 2 })); } - EvalCurve { degree: 2, knots, ctrl } + let periodic = (span - std::f64::consts::TAU).abs() < 1e-12; + (EvalCurve { degree: 2, knots, ctrl }, Arc { start: angle[0], step, count, periodic }) } /// A curve on [0, 1] run the other way: t becomes 1 − t.