Skip to content

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

Wave 285/509: Continuity: one table of orders G0-G4, and one check of what each construction builds (and 1 more)

jyvikoab4f92674bff
diff --git a/crates/doc/src/eval_surface.rs b/crates/doc/src/eval_surface.rs
index d7065a1f05..ff94db0e70 100644
--- a/crates/doc/src/eval_surface.rs
+++ b/crates/doc/src/eval_surface.rs
@@ -20,6 +20,10 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
if !edges.is_empty() {
let i = body_at(st, body, &crate::plain(edges))?;
let b = st.bodies.get(i).ok_or_else(|| DocError::Invalid("body".into()))?;
+ // A design may carry an order the fill does not build yet: refused, not built lower.
+ for g in std::iter::once(continuity.all).chain(continuity.edges.iter().map(|e| e.g)) {
+ g.built_by(kernel::Construction::Patch)?;
+ }
let spec = kernel::PatchSpec {
continuity: continuity.all,
edges: continuity.edges.iter().map(|e| (e.edge.0, e.g)).collect(),
diff --git a/crates/doc/src/format/pending/continuity-g4.rs b/crates/doc/src/format/pending/continuity-g4.rs
new file mode 100644
index 0000000000..62e6c8155b
--- /dev/null
+++ b/crates/doc/src/format/pending/continuity-g4.rs
@@ -0,0 +1,4 @@
+//! A continuity order may be saved as `g4` (the curvature's change also changes smoothly across
+//! the seam) wherever a design saves one (`g0` … `g3` before): a patch's, blend's, boundary's,
+//! loft's or match surface's continuity. An older design has none and means what it did. The last
+//! release refuses a design with this change (the newer format number) instead of misreading it.
diff --git a/crates/engine/src/cmd/sketch_create.rs b/crates/engine/src/cmd/sketch_create.rs
index dfa0d9328c..6088487029 100644
--- a/crates/engine/src/cmd/sketch_create.rs
+++ b/crates/engine/src/cmd/sketch_create.rs
@@ -440,14 +440,8 @@ fn end_of(sk: &Sketch, pi: usize) -> Option<(usize, Vec2)> {
fn blend_order(p: &Value, cmd: &str) -> Result<usize> {
match p.get("continuity") {
None | Some(Value::Null) => Ok(1),
- Some(Value::String(v)) => match v.trim().to_ascii_lowercase().as_str() {
- "" | "g1" => Ok(1),
- "g2" => Ok(2),
- "g3" => Ok(3),
- "g4" => Ok(4),
- _ => Err(bad(cmd, "`continuity` must be g1, g2, g3 or g4")),
- },
- Some(_) => Err(bad(cmd, "`continuity` must be g1, g2, g3 or g4")),
+ Some(Value::String(v)) if v.trim().is_empty() => Ok(1),
+ given => Ok(crate::params::continuity(cmd, given, "`continuity`", solidcraft_kernel::Construction::BlendCurve)?.order()),
}
}
diff --git a/crates/engine/src/cmd/sketch_inspect.rs b/crates/engine/src/cmd/sketch_inspect.rs
index 90fcf2518d..fd436a3797 100644
--- a/crates/engine/src/cmd/sketch_inspect.rs
+++ b/crates/engine/src/cmd/sketch_inspect.rs
@@ -571,8 +571,9 @@ mod tests {
assert_eq!(meridians, 5, "the meridians run from pole to pole");
}
- /// On a trimmed B-spline face (a spline profile's extruded side, with a hole through it) the
- /// isocurves are the surface's own rows and columns and stay inside the face's loops.
+ /// On a trimmed B-spline face (a spline profile's extruded side, with a hole through it: an
+ /// inner loop) the isocurves are the surface's own rows and columns and stay inside the face's
+ /// loops.
#[test]
fn isocurves_of_a_trimmed_spline_face_stay_inside_it() {
let mut s = Session::default();
@@ -581,8 +582,8 @@ mod tests {
s.execute("sketch.line", &json!({"points": [[40, 0], [0, 0]]})).unwrap();
s.execute("sketch.finish", &json!({})).unwrap();
s.execute("solid.extrude", &json!({"distance": 30})).unwrap();
- s.execute("solid.cylinder", &json!({"radius": 3, "height": 30, "base": [20, -10, 15], "axis": "Y", "operation": "cut"})).unwrap();
- let r = s.execute("inspect.isocurve", &json!({"faces": [[20, 8, 5]], "count": 12})).unwrap();
+ s.execute("solid.cylinder", &json!({"radius": 3, "height": 30, "base": [28, -10, 15], "axis": "Y", "operation": "cut"})).unwrap();
+ let r = s.execute("inspect.isocurve", &json!({"faces": [[28, 6.7, 5]], "count": 12})).unwrap();
let face = &r["faces"][0];
assert!(face["u_curves"].as_u64().unwrap() >= 12 && face["v_curves"].as_u64().unwrap() >= 12, "{face}");
let st = s.model.state();
@@ -604,7 +605,7 @@ mod tests {
.fold(f64::INFINITY, f64::min);
assert!(d < 2.0 * tol, "on the spline face: {q:?} is {d} from it");
assert!((-1e-6..=30.0 + 1e-6).contains(&q[2]) && q[1] > -1e-6, "{q:?}");
- assert!((q[0] - 20.0).hypot(q[2] - 15.0) > 3.0 - 1e-3, "not in the hole: {q:?}");
+ assert!((q[0] - 28.0).hypot(q[2] - 15.0) > 3.0 - 1e-3, "not in the hole: {q:?}");
}
}
}
diff --git a/crates/engine/src/cmd/surface.rs b/crates/engine/src/cmd/surface.rs
index 1e66925d76..0383998f5c 100644
--- a/crates/engine/src/cmd/surface.rs
+++ b/crates/engine/src/cmd/surface.rs
@@ -8,7 +8,7 @@ use solidcraft_doc::{
};
use solidcraft_doc::{BodyName, SketchId};
use solidcraft_doc::{Dir, FacePick, Position};
-use solidcraft_kernel::Continuity;
+use solidcraft_kernel::{Construction, Continuity};
use super::CommandSpec;
use super::features::{add_feature, axis_param, check_expr, extent_param, feature_sketch, operation, plane_param, profiles, sketch_id};
@@ -134,12 +134,9 @@ fn patch(s: &mut Session, p: &Value) -> Result<Value> {
Ok(v)
}
-/// A continuity word for a patch: g0, g1 or g2 (a patch does not hold g3).
+/// A continuity word for a patch, within what a patch builds ([`Construction::Patch`]).
fn patch_order(v: Option<&Value>, cmd: &str) -> Result<Continuity> {
- match v.and_then(Value::as_str).and_then(Continuity::parse) {
- Some(g) if g != Continuity::G3 => Ok(g),
- _ => Err(bad(cmd, "a patch's continuity is g0, g1 or g2")),
- }
+ crate::params::continuity(cmd, v, "a patch's continuity", Construction::Patch)
}
/// The patch's `continuity`: one word for every edge, a list of `{edge, g}` for some edges (the
@@ -172,7 +169,10 @@ fn patch_continuity(p: &Value, cmd: &str) -> Result<PatchContinuity> {
};
Ok(PatchContinuity { all, edges })
}
- Some(_) => Err(bad(cmd, "`continuity` must be g0, g1 or g2, or a list of {edge, g}")),
+ Some(_) => {
+ let (lowest, highest) = Construction::Patch.orders();
+ Err(bad(cmd, format!("`continuity` must be {}, or a list of {{edge, g}}", Continuity::words(lowest, highest))))
+ }
}
}
@@ -219,9 +219,7 @@ fn blend(s: &mut Session, p: &Value) -> Result<Value> {
None => [Continuity::G1, Continuity::G1],
Some(v) => {
let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`continuity` must be two words, one per end"))?;
- let word = |x: Option<&Value>| -> Result<Continuity> {
- x.and_then(Value::as_str).and_then(Continuity::parse).ok_or_else(|| bad(cmd, "`continuity` entries must be g0, g1, g2 or g3"))
- };
+ let word = |x: Option<&Value>| crate::params::continuity(cmd, x, "a `continuity` entry", Construction::Bridge);
[word(list.first())?, word(list.get(1))?]
}
};
@@ -413,9 +411,7 @@ fn surface_loft(s: &mut Session, p: &Value) -> Result<Value> {
None => [Continuity::G0, Continuity::G0],
Some(v) => {
let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`continuity` must be two words, one per end"))?;
- let word = |x: Option<&Value>| -> Result<Continuity> {
- x.and_then(Value::as_str).and_then(Continuity::parse).ok_or_else(|| bad(cmd, "`continuity` entries must be g0, g1, g2 or g3"))
- };
+ let word = |x: Option<&Value>| crate::params::continuity(cmd, x, "a `continuity` entry", Construction::Bridge);
[word(list.first())?, word(list.get(1))?]
}
};
diff --git a/crates/engine/src/cmd/surface_boundary.rs b/crates/engine/src/cmd/surface_boundary.rs
index 985ab6c644..86426579ea 100644
--- a/crates/engine/src/cmd/surface_boundary.rs
+++ b/crates/engine/src/cmd/surface_boundary.rs
@@ -6,7 +6,7 @@
use serde_json::Value;
use solidcraft_doc::{BodyName, FeatureKind, NetworkCurve, Operation, Position, SketchId};
-use solidcraft_kernel::Continuity;
+use solidcraft_kernel::{Construction, Continuity};
use super::CommandSpec;
use super::features::{add_feature, feature_sketch, sketch_id};
@@ -88,15 +88,12 @@ fn loop_patch(s: &mut Session, p: &Value) -> Result<Value> {
drop(state);
let orders = match p.get("continuity") {
None | Some(Value::Null) => vec![Continuity::G1; curves.len()],
- Some(Value::String(w)) => {
- let one = Continuity::parse(w).ok_or_else(|| bad(cmd, "`continuity` must be g0, g1, g2 or g3"))?;
- vec![one; curves.len()]
- }
+ Some(one @ Value::String(_)) => vec![crate::params::continuity(cmd, Some(one), "`continuity`", Construction::Bridge)?; curves.len()],
Some(v) => {
let list = v.as_array().filter(|a| a.len() == curves.len()).ok_or_else(|| bad(cmd, "`continuity` must be one word, or one per curve"))?;
let mut out = Vec::with_capacity(list.len());
for x in list {
- out.push(x.as_str().and_then(Continuity::parse).ok_or_else(|| bad(cmd, "`continuity` entries must be g0, g1, g2 or g3"))?);
+ out.push(crate::params::continuity(cmd, Some(x), "a `continuity` entry", Construction::Bridge)?);
}
out
}
@@ -205,10 +202,7 @@ fn network_curves(s: &Session, p: &Value, key: &str, default_sketch: &mut Option
}
}
if let Some(g) = o.get("continuity").filter(|v| !v.is_null()) {
- let g = g.as_str().and_then(Continuity::parse).ok_or_else(|| bad(cmd, format!("{name}.continuity must be g0, g1 or g2")))?;
- if g == Continuity::G3 {
- return Err(bad(cmd, format!("not supported yet: G3 on {name} (a curve network holds up to g2)")));
- }
+ let g = crate::params::continuity(cmd, Some(g), &format!("{name}.continuity"), Construction::Network)?;
if g != Continuity::G0 && curve.body.is_none() {
return Err(bad(cmd, format!("{name}: g1 and g2 apply to a curve on a body's edges (a surface's open edges)")));
}
diff --git a/crates/engine/src/cmd/surface_match.rs b/crates/engine/src/cmd/surface_match.rs
index 4121d0fe91..30d6d618cd 100644
--- a/crates/engine/src/cmd/surface_match.rs
+++ b/crates/engine/src/cmd/surface_match.rs
@@ -5,7 +5,7 @@
use serde_json::Value;
use solidcraft_doc::{BodyName, FacePick, FeatureKind, Position};
-use solidcraft_kernel::Continuity;
+use solidcraft_kernel::{Construction, Continuity};
use super::CommandSpec;
use super::features::add_feature;
@@ -43,7 +43,7 @@ fn match_surface(s: &mut Session, p: &Value) -> Result<Value> {
}
let order = match p.get("order") {
None => Continuity::G2,
- Some(v) => v.as_str().and_then(Continuity::parse).filter(|o| *o != Continuity::G0).ok_or_else(|| bad(cmd, "`order` must be g1, g2 or g3"))?,
+ Some(v) => crate::params::continuity(cmd, Some(v), "`order`", Construction::Match)?,
};
add_feature(
s,
diff --git a/crates/engine/src/params.rs b/crates/engine/src/params.rs
index 4960fc7467..c5bdc79fc4 100644
--- a/crates/engine/src/params.rs
+++ b/crates/engine/src/params.rs
@@ -4,7 +4,7 @@ use serde_json::Value;
use solidcraft_doc::Expr;
use solidcraft_geom::{Vec2, Vec3};
-use crate::{EngineError, Result};
+use crate::{EngineError, Result, kernel};
pub fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
EngineError::BadParams { cmd: cmd.to_string(), msg: msg.into() }
@@ -94,3 +94,18 @@ pub fn string_list(p: &Value, k: &str) -> Vec<String> {
_ => Vec::new(),
}
}
+
+/// A continuity word (`g0` … `g4`, [`kernel::Continuity::parse`]) for `what` (the key or entry
+/// it was given as), refused when it is not a word and when `by` does not build that order: the
+/// kernel's [`kernel::Construction`] table says which orders it does.
+pub fn continuity(cmd: &str, v: Option<&Value>, what: &str, by: kernel::Construction) -> Result<kernel::Continuity> {
+ let (lowest, highest) = by.orders();
+ let g = v
+ .and_then(Value::as_str)
+ .and_then(kernel::Continuity::parse)
+ .ok_or_else(|| bad(cmd, format!("{what} must be {}", kernel::Continuity::words(lowest, highest))))?;
+ g.built_by(by).map_err(|e| match e {
+ kernel::KernelError::Invalid(why) => bad(cmd, format!("{what}: {why}")),
+ other => other.into(),
+ })
+}
diff --git a/crates/kernel/src/boundary_network.rs b/crates/kernel/src/boundary_network.rs
index 1dcdc49b50..d369280063 100644
--- a/crates/kernel/src/boundary_network.rs
+++ b/crates/kernel/src/boundary_network.rs
@@ -18,7 +18,7 @@ use solidcraft_geom::network::{self, CrossFace, FaceFrame, NetCurve, NetworkCurv
use solidcraft_geom::{Plane, Seg2, Vec3};
use crate::body::Body;
-use crate::bridge::Continuity;
+use crate::continuity_order::{Construction, Continuity};
use crate::surfaces::{Chain, Parts, spline_curve, spline_surface, surface_body, uv_line};
use crate::{KernelError, Result};
@@ -33,13 +33,18 @@ pub const MAX_EDGE_PICKS: usize = 10_000;
/// Most sketch curves one curve of a boundary surface chains.
pub const MAX_CHAIN_CURVES: usize = 1000;
-/// The network's continuity for a curve's: G3 is refused (a network holds up to G2).
+/// The network's continuity for a curve's, refused past what a network builds
+/// ([`Construction::Network`]).
fn net_order(c: &BoundaryCurve) -> Result<network::Continuity> {
- match c.continuity {
+ let named = |e: KernelError| match e {
+ KernelError::Invalid(why) => KernelError::Invalid(format!("{}: {why}", c.label)),
+ other => other,
+ };
+ match c.continuity.built_by(Construction::Network).map_err(named)? {
Continuity::G0 => Ok(network::Continuity::G0),
Continuity::G1 => Ok(network::Continuity::G1),
Continuity::G2 => Ok(network::Continuity::G2),
- Continuity::G3 => Err(KernelError::Invalid(format!("not supported yet: G3 continuity on {} (a curve network holds up to G2)", c.label))),
+ higher => Err(KernelError::Failed(format!("a curve network has no {} condition yet", higher.code()))),
}
}
@@ -732,17 +737,16 @@ mod tests {
assert!((k1 + 1.0 / r).abs() > 0.1 / r, "G1 alone does not carry the curvature: {k1}");
}
- /// G3 is more than a network holds: refused, never a panic.
+ /// G3 and G4 are more than a network holds: refused, naming the curve, never a panic.
#[test]
fn g3_is_not_supported() {
let base = sheet();
- let edge = BoundaryCurve {
- label: "edge".into(),
- source: CurveSource::Edges { body: &base, at: vec![Vec3::new(5.0, 0.0, 0.0)] },
- continuity: Continuity::G3,
- };
- let e = boundary_surface(&[edge, line3("far", Vec3::new(0.0, 10.0, 5.0), Vec3::new(10.0, 10.0, 5.0))], &[]).unwrap_err();
- assert!(e.to_string().contains("not supported yet"), "{e}");
+ for g in [Continuity::G3, Continuity::G4] {
+ let edge =
+ BoundaryCurve { label: "edge".into(), source: CurveSource::Edges { body: &base, at: vec![Vec3::new(5.0, 0.0, 0.0)] }, continuity: g };
+ let e = boundary_surface(&[edge, line3("far", Vec3::new(0.0, 10.0, 5.0), Vec3::new(10.0, 10.0, 5.0))], &[]).unwrap_err();
+ assert!(e.to_string().contains("not supported yet") && e.to_string().contains("edge") && e.to_string().contains(g.as_str()), "{e}");
+ }
}
/// Refusals: G1 on a sketch curve, on an edge between two faces, curves that miss.
diff --git a/crates/kernel/src/bridge.rs b/crates/kernel/src/bridge.rs
index f8ae8e7b13..f76860cb36 100644
--- a/crates/kernel/src/bridge.rs
+++ b/crates/kernel/src/bridge.rs
@@ -1,5 +1,5 @@
//! Continuity-driven bridging surfaces: one B-spline face that leaves one surface and arrives at
-//! another with a requested continuity (G0 up to G3). This is the core the Blend, Boundary and
+//! another with a requested continuity (G0 up to G3, [`Construction::Bridge`]). This is the core the Blend, Boundary and
//! Match surfaces are built on.
//!
//! A bridge is a tensor product. Across it (v) every station's cross-section is a Bézier whose
@@ -22,57 +22,11 @@ use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
use solidcraft_geom::bspline::{CurveN, HPoint, NurbsSurface};
use crate::body::Body;
+use crate::continuity_order::Construction;
+pub use crate::continuity_order::Continuity;
use crate::surfaces::Chain;
use crate::{KernelError, Result};
-/// How much of a support surface a bridge repeats along its boundary.
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Continuity {
- /// The boundary curve alone: the surfaces meet, nothing else.
- G0,
- /// Position and tangent plane.
- #[default]
- G1,
- /// Position, tangent plane and curvature vector.
- G2,
- /// Position, tangent plane, curvature vector and its change along the leave direction.
- G3,
-}
-
-impl Continuity {
- /// Conditions a side carries: 1 (G0) up to 4 (G3).
- pub fn conditions(self) -> usize {
- match self {
- Continuity::G0 => 1,
- Continuity::G1 => 2,
- Continuity::G2 => 3,
- Continuity::G3 => 4,
- }
- }
-
- /// The word a command parameter uses.
- pub fn as_str(self) -> &'static str {
- match self {
- Continuity::G0 => "g0",
- Continuity::G1 => "g1",
- Continuity::G2 => "g2",
- Continuity::G3 => "g3",
- }
- }
-
- /// Parse `g0`…`g3` (upper case accepted), `None` for anything else.
- pub fn parse(s: &str) -> Option<Continuity> {
- match s.to_ascii_lowercase().as_str() {
- "g0" => Some(Continuity::G0),
- "g1" => Some(Continuity::G1),
- "g2" => Some(Continuity::G2),
- "g3" => Some(Continuity::G3),
- _ => None,
- }
- }
-}
-
/// One station of a boundary: where the bridge starts, the direction it leaves in, and what the
/// support surface does there along that direction.
#[derive(Clone, Copy, Debug)]
@@ -684,6 +638,9 @@ pub fn bridge(a: &[Frame], b: &[Frame], orders: [Continuity; 2], crown: [f64; 2]
return Err(KernelError::Invalid("a bridge's crown must be between -0.9 and 3".into()));
}
}
+ for g in orders {
+ g.built_by(Construction::Bridge)?;
+ }
let stations = a.len();
let n = orders[0].conditions() + orders[1].conditions() - 1;
if n == 0 || n > solidcraft_geom::bspline::MAX_SPLINE_DEGREE {
diff --git a/crates/kernel/src/bridge_tests.rs b/crates/kernel/src/bridge_tests.rs
index 54bb131155..ff2980e3e4 100644
--- a/crates/kernel/src/bridge_tests.rs
+++ b/crates/kernel/src/bridge_tests.rs
@@ -209,6 +209,9 @@ fn the_bridge_refuses_what_it_cannot_hold() {
assert!(bridge(&bad, &b, [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
// Fewer than two stations.
assert!(bridge(&a[..1], &b[..1], [Continuity::G1, Continuity::G1], [0.0, 0.0]).is_err());
+ // G4 is past the bridge's Hermite rows: refused by the one check, not built as G3.
+ let e = bridge(&a, &b, [Continuity::G4, Continuity::G1], [0.0, 0.0]).unwrap_err().to_string();
+ assert!(e.contains("not supported yet") && e.contains("g4"), "{e}");
// Every order from G0 to G3 builds.
for (x, y) in [(Continuity::G0, Continuity::G0), (Continuity::G1, Continuity::G0), (Continuity::G3, Continuity::G1)] {
let body = bridge(&a, &b, [x, y], [0.0, 0.0]).unwrap();
@@ -219,15 +222,6 @@ fn the_bridge_refuses_what_it_cannot_hold() {
}
}
-#[test]
-fn continuity_parses_its_words() {
- assert_eq!(Continuity::parse("g0"), Some(Continuity::G0));
- assert_eq!(Continuity::parse("G3"), Some(Continuity::G3));
- assert_eq!(Continuity::parse("g9"), None);
- assert_eq!(Continuity::parse(""), None);
- assert_eq!([Continuity::G0, Continuity::G1, Continuity::G2, Continuity::G3].map(Continuity::conditions), [1, 2, 3, 4]);
-}
-
/// A radius-10 tube along z from `z0` to `z0 + 30`, turned `turn` radians about its axis (which
/// moves where its rim's seam sits), with the end face at `open_at` taken off: a surface body
/// whose rim there is a closed chain.
diff --git a/crates/kernel/src/continuity_order.rs b/crates/kernel/src/continuity_order.rs
new file mode 100644
index 0000000000..2e93d27ea1
--- /dev/null
+++ b/crates/kernel/src/continuity_order.rs
@@ -0,0 +1,237 @@
+//! The orders of geometric continuity, G0 to G4, in one table: the word a command parameter and
+//! a design file use (`g0` … `g4`), the code shown in hover texts, help and messages (`G0` …
+//! `G4`), and the message ids of the plain word a control shows (Position, Tangent, Curvature,
+//! Curvature change, Smooth curvature change) and of its hover text. Labels never show the code.
+//!
+//! Each order adds one condition across a seam: G0 the position, G1 the tangent plane, G2 the
+//! curvature, G3 how the curvature changes across the seam (its first derivative by arc length),
+//! G4 how that change itself changes (the second derivative).
+//!
+//! [`Construction`] says which orders each construction builds today, and
+//! [`Continuity::built_by`] is the one check that refuses the rest.
+
+use crate::{KernelError, Result};
+
+/// How smoothly a surface or curve continues across a seam: the number of derivatives it shares.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Continuity {
+ /// The position alone: the surfaces meet, with a crease where they do.
+ G0,
+ /// Position and tangent plane.
+ #[default]
+ G1,
+ /// Position, tangent plane and curvature.
+ G2,
+ /// Position, tangent plane, curvature and the change of curvature across the seam.
+ G3,
+ /// All of G3, and how that change of curvature itself changes.
+ G4,
+}
+
+/// One row of the table: what an order is called where.
+struct Words {
+ /// The command parameter and design-file word.
+ word: &'static str,
+ /// The code, for hover texts, help and messages only.
+ code: &'static str,
+ /// The message id of the plain word a control shows.
+ label: &'static str,
+ /// The message id of the hover text, which names the code.
+ tip: &'static str,
+}
+
+/// The table, indexed by [`Continuity::order`].
+const WORDS: [Words; 5] = [
+ Words { word: "g0", code: "G0", label: "ui.continuity_position", tip: "ui.continuity_position_tip" },
+ Words { word: "g1", code: "G1", label: "ui.continuity_tangent", tip: "ui.continuity_tangent_tip" },
+ Words { word: "g2", code: "G2", label: "ui.continuity_curvature", tip: "ui.continuity_curvature_tip" },
+ Words { word: "g3", code: "G3", label: "ui.continuity_curvature_change", tip: "ui.continuity_curvature_change_tip" },
+ Words { word: "g4", code: "G4", label: "ui.continuity_smooth_curvature_change", tip: "ui.continuity_smooth_curvature_change_tip" },
+];
+
+impl Continuity {
+ /// Every order, from G0 up.
+ pub const ALL: [Continuity; 5] = [Continuity::G0, Continuity::G1, Continuity::G2, Continuity::G3, Continuity::G4];
+
+ /// The number of derivatives across the seam it fixes: 0 (G0) up to 4 (G4).
+ pub fn order(self) -> usize {
+ self as usize
+ }
+
+ /// The order with `order` derivatives, `None` past G4.
+ pub fn from_order(order: usize) -> Option<Continuity> {
+ Continuity::ALL.get(order).copied()
+ }
+
+ /// Conditions a side carries: the position and one per derivative, 1 (G0) up to 5 (G4).
+ pub fn conditions(self) -> usize {
+ self.order() + 1
+ }
+
+ /// The word a command parameter and a design use: `g0` … `g4`.
+ pub fn as_str(self) -> &'static str {
+ self.row().word
+ }
+
+ /// The code `G0` … `G4`: for hover texts, help and messages, never a label.
+ pub fn code(self) -> &'static str {
+ self.row().code
+ }
+
+ /// The message id of the plain word a control shows for this order.
+ pub fn label_id(self) -> &'static str {
+ self.row().label
+ }
+
+ /// The message id of this order's hover text (which names its code).
+ pub fn tip_id(self) -> &'static str {
+ self.row().tip
+ }
+
+ /// Parse a word (`g0` … `g4`, either case, surrounding blanks ignored); `None` for anything else.
+ pub fn parse(s: &str) -> Option<Continuity> {
+ let s = s.trim();
+ Continuity::ALL.into_iter().find(|g| g.as_str().eq_ignore_ascii_case(s))
+ }
+
+ /// The words of `from` up to `to` for a message: "g0, g1 or g2".
+ pub fn words(from: Continuity, to: Continuity) -> String {
+ let words: Vec<&str> = Continuity::ALL.into_iter().filter(|g| (from..=to).contains(g)).map(Continuity::as_str).collect();
+ match words.split_last() {
+ Some((last, [])) => (*last).to_string(),
+ Some((last, rest)) => format!("{} or {last}", rest.join(", ")),
+ None => String::new(),
+ }
+ }
+
+ /// This order if `by` builds it, else a refusal that names the orders it does build. The one
+ /// check every command and kernel entry point makes ([`Construction`]).
+ pub fn built_by(self, by: Construction) -> Result<Continuity> {
+ let (lowest, highest) = by.orders();
+ if self < lowest {
+ return Err(KernelError::Invalid(format!("{} takes {}", by.what(), Continuity::words(lowest, highest))));
+ }
+ if self > highest {
+ return Err(KernelError::Invalid(format!(
+ "not supported yet: {} is built with {}, not {}",
+ by.what(),
+ Continuity::words(lowest, highest),
+ self.as_str()
+ )));
+ }
+ Ok(self)
+ }
+
+ fn row(self) -> &'static Words {
+ // `WORDS` has a row for every variant (`order` is at most 4).
+ &WORDS[self.order()]
+ }
+}
+
+/// What builds geometry to a continuity order, and the orders each one builds today.
+///
+/// HAND-OFF POINT: this table is the only place that says how far a construction goes. When a
+/// construction learns a higher order, raise its `highest` in [`Construction::orders`] (for the
+/// patch, from the fill's own `supported_orders` once it has one); every command, dialog and
+/// kernel entry point reads it from here, so nothing else changes.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Construction {
+ /// A patch filling a loop of edges (`surface.patch`).
+ Patch,
+ /// A bridge of Hermite rows: a blend surface, a boundary patch on a loop of sketch curves, a
+ /// loft's ends and a match surface's seam.
+ Bridge,
+ /// A surface through a curve network (`surface.boundary` with `u` and `v` curves).
+ Network,
+ /// A match surface: a bridge that must at least share the tangent plane.
+ Match,
+ /// A sketch blend curve (`sketch.blend_curve`): one Bézier through G1 … G4.
+ BlendCurve,
+}
+
+impl Construction {
+ /// The lowest and the highest order this construction builds.
+ pub fn orders(self) -> (Continuity, Continuity) {
+ match self {
+ Construction::Patch => (Continuity::G0, Continuity::G2),
+ Construction::Bridge => (Continuity::G0, Continuity::G3),
+ Construction::Network => (Continuity::G0, Continuity::G2),
+ Construction::Match => (Continuity::G1, Construction::Bridge.orders().1),
+ Construction::BlendCurve => (Continuity::G1, Continuity::G4),
+ }
+ }
+
+ /// Whether this construction builds `g`.
+ pub fn builds(self, g: Continuity) -> bool {
+ let (lowest, highest) = self.orders();
+ (lowest..=highest).contains(&g)
+ }
+
+ /// The orders it builds, from its lowest up: what a dialog offers.
+ pub fn offered(self) -> Vec<Continuity> {
+ Continuity::ALL.into_iter().filter(|g| self.builds(*g)).collect()
+ }
+
+ /// What it is called in a message.
+ fn what(self) -> &'static str {
+ match self {
+ Construction::Patch => "a patch",
+ Construction::Bridge => "a blend, boundary, loft or match surface",
+ Construction::Network => "a curve network",
+ Construction::Match => "a match surface",
+ Construction::BlendCurve => "a blend curve",
+ }
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn every_order_round_trips_through_its_word_and_serde() {
+ for (k, g) in Continuity::ALL.into_iter().enumerate() {
+ assert_eq!(g.order(), k);
+ assert_eq!(Continuity::from_order(k), Some(g));
+ assert_eq!(g.conditions(), k + 1);
+ assert_eq!(g.as_str(), format!("g{k}"));
+ assert_eq!(g.code(), format!("G{k}"));
+ assert_eq!(Continuity::parse(g.as_str()), Some(g));
+ assert_eq!(Continuity::parse(&format!(" {} ", g.code())), Some(g));
+ // The design file's word is the command word.
+ assert_eq!(serde_json::to_value(g).unwrap(), serde_json::json!(g.as_str()));
+ assert_eq!(serde_json::from_value::<Continuity>(serde_json::json!(g.as_str())).unwrap(), g);
+ }
+ assert_eq!(Continuity::from_order(5), None);
+ for word in ["", "g5", "G-1", "curvature", "g 1"] {
+ assert_eq!(Continuity::parse(word), None, "{word:?}");
+ }
+ }
+
+ #[test]
+ fn labels_are_words_and_tips_are_their_own() {
+ let ids: Vec<&str> = Continuity::ALL.iter().flat_map(|g| [g.label_id(), g.tip_id()]).collect();
+ for (i, id) in ids.iter().enumerate() {
+ assert!(id.starts_with("ui.continuity_"), "{id}");
+ assert!(!ids[..i].contains(id), "{id} twice");
+ assert!(!id.contains("_g"), "a message id names its word, not its code: {id}");
+ }
+ }
+
+ #[test]
+ fn a_construction_refuses_what_it_does_not_build_and_names_what_it_does() {
+ assert_eq!(Continuity::words(Continuity::G0, Continuity::G2), "g0, g1 or g2");
+ assert_eq!(Continuity::words(Continuity::G4, Continuity::G4), "g4");
+ assert_eq!(Continuity::G2.built_by(Construction::Patch).unwrap(), Continuity::G2);
+ let e = Continuity::G3.built_by(Construction::Patch).unwrap_err().to_string();
+ assert!(e.contains("not supported yet") && e.contains("g0, g1 or g2") && e.contains("g3"), "{e}");
+ let e = Continuity::G0.built_by(Construction::Match).unwrap_err().to_string();
+ assert!(e.contains("g1, g2 or g3"), "{e}");
+ assert!(Continuity::G4.built_by(Construction::Bridge).is_err());
+ assert!(Continuity::G4.built_by(Construction::BlendCurve).is_ok());
+ assert_eq!(Construction::Patch.offered(), vec![Continuity::G0, Continuity::G1, Continuity::G2]);
+ assert_eq!(Construction::BlendCurve.offered().first(), Some(&Continuity::G1));
+ }
+}
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 3aaa6b2619..527b4fab4c 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -28,6 +28,7 @@ mod build;
#[cfg(test)]
mod chamfer_sides_curved_tests;
mod continuity;
+mod continuity_order;
#[cfg(test)]
mod coplanar_tests;
mod corner_g2;
@@ -161,7 +162,7 @@ pub use blend_variable::{RadiusSpline, Taper, fillet_chord, fillet_tapered, fill
pub use body::{Body, CapSignature, DISPLAY_ANGLE, DisplayShare, EdgeInfo, FaceInfo, FacePaint, FaceSource, MeshTolerance, Paint};
pub use boundary::{Boundary, boundary_patch};
pub use boundary_network::{BoundaryCurve, CurveSource, MAX_CHAIN_CURVES, MAX_EDGE_PICKS, boundary_join, boundary_surface};
-pub use bridge::{Continuity, Frame, blend_between, bridge, chain, chain_closes, frames, frames_across, sample_grid};
+pub use bridge::{Frame, blend_between, bridge, chain, chain_closes, frames, frames_across, sample_grid};
pub use build::{
PathSeg, box_solid, canonical_revolve_axis, cylinder, extrude, extrude_tapered, extrude_tapered_between, extrude_whole_sides, loft, loft_regions,
loft_with_rails, path_polyline, planar_face_record, revolve, revolve_whole, sphere, sweep, sweep_with, torus,
@@ -170,6 +171,7 @@ pub use continuity::{
ContinuityReport, ContinuityTolerances, EdgePick, MAX_SAMPLES, MIN_SAMPLES, SeamReport, SeamStation, SeamVerdict, SeamWorst, pick_edges,
seam_diagnostics,
};
+pub use continuity_order::{Construction, Continuity};
pub use corner_g2::{CURVATURE_SHARE, DEFAULT_SETBACK_FACTOR};
pub use delete_face::delete_faces;
pub use distance::{BodyDistance, DistanceShape, body_distance};
diff --git a/crates/kernel/src/loft_blend.rs b/crates/kernel/src/loft_blend.rs
index 27e76e04eb..3c1899dbfc 100644
--- a/crates/kernel/src/loft_blend.rs
+++ b/crates/kernel/src/loft_blend.rs
@@ -77,6 +77,9 @@ const ROWS_PER_SOLVE: usize = 16;
/// [`MAX_BLEND_STATIONS`], a frame that is not finite or a `leave` with no direction, a crown
/// outside its range, and two neighbouring sections that meet at a station (no room for a blend).
pub fn loft_blend(sections: &[Vec<Frame>], orders: [Continuity; 2], crown: [f64; 2], samples: usize) -> Result<Body> {
+ for g in orders {
+ g.built_by(crate::continuity_order::Construction::Bridge)?;
+ }
let blend = Blend::new(sections, orders, crown, samples)?;
let net = blend.net()?;
crate::surfaces::tensor_sheet(&net)