Prepare to support sweeps along curves

Bump the cargo group with 2 updates

.github/workflows/ci.yml

@@ -48,7 +48,9 @@ jobs:
         os:
           - ubuntu-latest
           - macOS-latest
-          - windows-latest
+          # Windows CI build disabled for the time being. More information:
+          # https://github.com/hannobraun/fornjot/issues/2376
+          # - windows-latest
     runs-on: ${{matrix.os}}
     steps:
       - name: Check out repository

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Continuous Deployment
+name: Release Automation
 
 on:
   push:

CONTRIBUTING.md

@@ -102,9 +102,7 @@ There are a lot of open issues, however. If you need some more guidance, there a
 - Some issues that need extra attention are labeled as [`help wanted`](https://github.com/hannobraun/Fornjot/labels/help%20wanted). Don't take that too seriously though. Help is welcome everywhere, not just on issues explicitly labeled as such.
 - Issues are typically labeled by topic to indicate which part of the project they affect. Check out the [list of labels](https://github.com/hannobraun/Fornjot/labels), specifically the various `topic: ` labels.
 
-There's also the [feature wishlist](https://github.com/hannobraun/fornjot/discussions/146), for things that are not as actionable right now, or that I didn't want to track as issues for other reasons.
-
-Finally, feel free to just ask. If you have a specific issue in mind, just comment there. Or direct your query to [Matrix] or [Discussions].
+Always feel free to just ask. If you have a specific issue in mind, just comment there. Or direct your query to [Matrix] or [Discussions].
 
 If you're not a programmer, or are looking for some variety, you can also work on [the website](https://github.com/hannobraun/www.fornjot.app).
 

Cargo.toml

@@ -31,13 +31,12 @@ default-members = [
     "crates/fj-interop",
     "crates/fj-math",
     "crates/fj-viewer",
-    "crates/fj-window",
 ]
 
 
 [workspace.package]
 version = "0.49.0"
-edition = "2021"
+edition = "2024"
 
 description = "Early-stage b-rep CAD kernel."
 readme = "README.md"
@@ -81,7 +80,3 @@ path = "crates/fj-math"
 [workspace.dependencies.fj-viewer]
 version = "0.49.0"
 path = "crates/fj-viewer"
-
-[workspace.dependencies.fj-window]
-version = "0.49.0"
-path = "crates/fj-window"

README.md

@@ -22,7 +22,7 @@ For more information, [please check out the website](https://www.fornjot.app/).
 
 ## Sponsors
 
-Fornjot is supported by [**@MitchellHansen**](https://github.com/MitchellHansen), [**@webtrax-oz**](https://github.com/webtrax-oz), [**@seanjensengrey**](https://github.com/seanjensengrey), [**@reivilibre**](https://github.com/reivilibre), [**@lthiery**](https://github.com/lthiery), [**@ahdinosaur**](https://github.com/ahdinosaur), [**@martindederer**](https://github.com/martindederer), [**@bollian**](https://github.com/bollian), [**@sucaba**](https://github.com/sucaba), [**@nullstyle**](https://github.com/nullstyle), [**@tachiniererin**](https://github.com/tachiniererin), [**@HalfVoxel**](https://github.com/HalfVoxel), [**@MattOslin**](https://github.com/MattOslin), [**@jminer**](https://github.com/jminer), [**@voxpelli**](https://github.com/voxpelli), [**@U007D**](https://github.com/U007D), [**@guillaumechauvat**](https://github.com/guillaumechauvat), [**@mayfieldiv**](https://github.com/mayfieldiv), [**@bglw**](https://github.com/bglw), [**@hansihe**](https://github.com/hansihe), [**@romixlab**](https://github.com/romixlab), [**@krl**](https://github.com/krl), and [my other awesome sponsors](https://github.com/sponsors/hannobraun). Thank you!
+Fornjot is supported by [**@reivilibre**](https://github.com/reivilibre), [**@thestig4242**](https://github.com/thestig4242), [**@thomasgarrison**](https://github.com/thomasgarrison), [**@seanjensengrey**](https://github.com/seanjensengrey), [**@lthiery**](https://github.com/lthiery), [**@ahdinosaur**](https://github.com/ahdinosaur), [**@martindederer**](https://github.com/martindederer), [**@sucaba**](https://github.com/sucaba), [**@MitchellHansen**](https://github.com/MitchellHansen), [**@Rahix**](https://github.com/Rahix), [**@JanBerktold**](https://github.com/JanBerktold), [**@darwin**](https://github.com/darwin), [**@nullstyle**](https://github.com/nullstyle), [**@HalfVoxel**](https://github.com/HalfVoxel), [**@jessebraham**](https://github.com/jessebraham), [**@jminer**](https://github.com/jminer), [**@U007D**](https://github.com/U007D), [**@guillaumechauvat**](https://github.com/guillaumechauvat), [**@mayfieldiv**](https://github.com/mayfieldiv), [**@bglw**](https://github.com/bglw), [**@refarb**](https://github.com/refarb), [**@hansihe**](https://github.com/hansihe), [**@romixlab**](https://github.com/romixlab), [**@justinmimbs**](https://github.com/justinmimbs), [**@yikesable**](https://github.com/yikesable), [**@hrgdavor**](https://github.com/hrgdavor), [**@ironchief**](https://github.com/ironchief), [**@kingsmountainlabs**](https://github.com/kingsmountainlabs), [**@epyintheshell**](https://github.com/epyintheshell), [**@jneem**](https://github.com/jneem), [**@keithamus**](https://github.com/keithamus), [**@starthal**](https://github.com/starthal), and [my other awesome sponsors](https://github.com/sponsors/hannobraun). Thank you!
 
 **Please consider [supporting me too](https://github.com/sponsors/hannobraun), to help make Fornjot sustainable long-term.**
 
@@ -39,7 +39,13 @@ Fornjot is supported by [**@MitchellHansen**](https://github.com/MitchellHansen)
 
 ## Status
 
-Fornjot is usable for simple models (see [examples](examples/)), but currently lacks the features for anything more advanced. Work to change that is underway.
+Fornjot is usable for simple models (see [`models/` directory](models)), but currently lacks the features for anything more advanced. Work to change that is underway.
+
+Despite this, there are some experimental projects that are build on top of Fornjot:
+
+- [CommandCAD](https://github.com/IamTheCarl/CommandCAD)
+- [`fj-text`](https://github.com/samgoldman/fj-text)
+- [`bevy_mod_fornjot`](https://github.com/TotalKrill/bevy_mod_fornjot)
 
 
 ## Overview

crates/fj-core/Cargo.toml

@@ -16,13 +16,13 @@ workspace = true
 [dependencies]
 fj-interop.workspace = true
 fj-math.workspace = true
-itertools = "0.12.1"
-parking_lot = "0.12.0"
+itertools = "0.14.0"
+parking_lot = "0.12.3"
 robust = "1.1.0"
-spade = "2.6.0"
-thiserror = "1.0.58"
+spade = "2.13.1"
+thiserror = "2.0.12"
 type-map = "0.5.0"
 
 [dev-dependencies]
-pretty_assertions = "1.4.0"
-anyhow = "1.0.81"
+pretty_assertions = "1.4.1"
+anyhow = "1.0.98"

crates/fj-core/src/algorithms/approx/circle.rs

@@ -0,0 +1,57 @@
+use fj_interop::Tolerance;
+use fj_math::{Circle, Point};
+
+use crate::geometry::{CurveBoundary, traits::GenPolyline};
+
+/// # Approximate a circle
+///
+/// ## Arguments
+///
+/// Besides a circle, this method takes two arguments:
+///
+/// - The `boundary` within which the circle should be approximated.
+/// - The `tolerance` that specifies how much the approximation is allowed to
+///   deviate from the actual circle.
+///
+/// ## Return Value
+///
+/// The approximation returns points within the provided boundary. The boundary
+/// points themselves are not included in the approximation. This gives the
+/// caller (who knows the boundary anyway) more options for how to further
+/// process the approximation.
+///
+/// ## Determinism
+///
+/// Circle approximation is carefully designed to produce a deterministic result
+/// for the combination of a given circle and tolerance, regardless of the
+/// boundary. This is done to prevent invalid meshes from being generated.
+///
+/// In specific terms, this means there is an infinite set of points that
+/// approximates a circle (infinite, since the circle's local coordinate space
+/// is infinite). That set is deterministic for a given combination of circle
+/// and tolerance. The boundary that defines where the circle is approximated
+/// only influences the result in two ways:
+///
+/// 1. It controls which points from the infinite set are actually computed.
+/// 2. It defines the order in which the computed points are returned.
+///
+/// As a result, circle approximation is guaranteed to generate points that can
+/// fit together in a valid mesh, no matter which ranges of a path are being
+/// approximated, and how many times.
+pub fn approx_circle<const D: usize>(
+    circle: &Circle<D>,
+    boundary: impl Into<CurveBoundary<Point<1>>>,
+    tolerance: impl Into<Tolerance>,
+) -> Vec<(Point<1>, Point<D>)> {
+    let boundary = boundary.into();
+    let tolerance = tolerance.into();
+
+    let mut points = Vec::new();
+
+    for point_curve in circle.generate_polyline(boundary, tolerance) {
+        let point_global = circle.point_from_circle_coords(point_curve);
+        points.push((point_curve, point_global));
+    }
+
+    points
+}

crates/fj-core/src/algorithms/approx/curve.rs

@@ -1,135 +1,158 @@
-//! Curve approximation
-
 use std::collections::BTreeMap;
 
-use fj_math::Point;
+use fj_interop::Tolerance;
+use fj_math::{Circle, Line, Point};
 
 use crate::{
-    geometry::{CurveBoundary, GlobalPath, SurfaceGeometry, SurfacePath},
-    objects::Curve,
-    storage::{Handle, HandleWrapper},
-    Core,
+    geometry::{
+        CurveBoundary, Geometry, Path,
+        repr::tri_mesh::convert_point_surface_to_global, surfaces::SweptCurve,
+    },
+    storage::Handle,
+    topology::{Curve, Surface},
 };
 
-use super::{Approx, ApproxPoint, Tolerance};
+use super::{ApproxPoint, circle::approx_circle, line::approx_line};
 
-impl Approx
-    for (
-        &Handle<Curve>,
-        SurfacePath,
-        &SurfaceGeometry,
-        CurveBoundary<Point<1>>,
-    )
-{
-    type Approximation = CurveApprox;
-    type Cache = CurveApproxCache;
-
-    fn approx_with_cache(
-        self,
+/// Approximate the provided curve
+///
+/// The approximation is cached, and cached approximations are used, where
+/// possible.
+pub fn approx_curve_with_cache(
+    curve: &Handle<Curve>,
+    surface: &Handle<Surface>,
+    boundary: CurveBoundary<Point<1>>,
     tolerance: impl Into<Tolerance>,
-        cache: &mut Self::Cache,
-        core: &mut Core,
-    ) -> Self::Approximation {
-        let (curve, surface_path, surface, boundary) = self;
-
+    cache: &mut CurveApproxCache,
+    geometry: &Geometry,
+) -> CurveApprox {
     match cache.get(curve, boundary) {
         Some(approx) => approx,
         None => {
             let approx = approx_curve(
-                    &surface_path,
-                    surface,
+                &geometry
+                    .of_curve(curve)
+                    .unwrap()
+                    .local_on(surface)
+                    .unwrap()
+                    .path,
+                geometry.of_surface(surface),
                 boundary,
                 tolerance,
-                    core,
+                geometry,
             );
 
             cache.insert(curve.clone(), boundary, approx)
         }
     }
-    }
 }
 
 fn approx_curve(
-    path: &SurfacePath,
-    surface: &SurfaceGeometry,
+    path: &Path<2>,
+    surface: &SweptCurve,
     boundary: CurveBoundary<Point<1>>,
     tolerance: impl Into<Tolerance>,
-    core: &mut Core,
+    geometry: &Geometry,
 ) -> CurveApprox {
-    // There are different cases of varying complexity. Circles are the hard
-    // part here, as they need to be approximated, while lines don't need to be.
-    //
-    // This will probably all be unified eventually, as `SurfacePath` and
-    // `GlobalPath` grow APIs that are better suited to implementing this code
-    // in a more abstract way.
-    let points = match (path, surface.u) {
-        (SurfacePath::Circle(_), GlobalPath::Circle(_)) => {
-            todo!(
-                "Approximating a circle on a curved surface not supported yet."
+    let SweptCurve { u, .. } = surface;
+    let points = match (path, u) {
+        (Path::Circle(_), Path::Circle(_)) => approx_circle_on_curved_surface(),
+        (Path::Circle(circle), Path::Line(_)) => {
+            approx_circle_on_straight_surface(
+                circle, boundary, surface, tolerance, geometry,
             )
         }
-        (SurfacePath::Circle(_), GlobalPath::Line(_)) => {
-            (path, boundary)
-                .approx_with_cache(tolerance, &mut (), core)
+        (Path::Line(line), _) => approx_line_on_any_surface(
+            line, boundary, surface, tolerance, geometry,
+        ),
+    };
+
+    CurveApprox { points }
+}
+
+fn approx_circle_on_curved_surface() -> Vec<ApproxPoint<1>> {
+    todo!("Approximating a circle on a curved surface is not supported yet.")
+}
+
+fn approx_circle_on_straight_surface(
+    circle: &Circle<2>,
+    boundary: CurveBoundary<Point<1>>,
+    surface: &SweptCurve,
+    tolerance: impl Into<Tolerance>,
+    geometry: &Geometry,
+) -> Vec<ApproxPoint<1>> {
+    let tolerance = tolerance.into();
+
+    approx_circle(circle, boundary, tolerance)
         .into_iter()
         .map(|(point_curve, point_surface)| {
-                    // We're throwing away `point_surface` here, which is a
-                    // bit weird, as we're recomputing it later (outside of
-                    // this function).
+            // We're throwing away `point_surface` here, which is a bit weird,
+            // as we're recomputing it later (outside of this function).
             //
             // It should be fine though:
             //
-                    // 1. We're throwing this version away, so there's no
-                    //    danger of inconsistency between this and the later
-                    //    version.
-                    // 2. This version should have been computed using the
-                    //    same path and parameters and the later version
-                    //    will be, so they should be the same anyway.
-                    // 3. Not all other cases handled in this function have
-                    //    a surface point available, so it needs to be
-                    //    computed later anyway, in the general case.
+            // 1. We're throwing this version away, so there's no danger of
+            //    inconsistency between this and the later version.
+            // 2. This version should have been computed using the same path and
+            //    parameters and the later version will be, so they should be
+            //    the same anyway.
+            // 3. Not all other cases handled in this function have a surface
+            //    point available, so it needs to be computed later anyway, in
+            //    the general case.
 
-                    let point_global =
-                        surface.point_from_surface_coords(point_surface);
-                    (point_curve, point_global)
+            let point_global = convert_point_surface_to_global(
+                surface,
+                point_surface,
+                tolerance,
+                geometry,
+            );
+            ApproxPoint::new(point_curve, point_global)
         })
         .collect()
-        }
-        (SurfacePath::Line(line), _) => {
-            let range_u =
-                CurveBoundary::from(boundary.inner.map(|point_curve| {
-                    [path.point_from_path_coords(point_curve).u]
-                }));
+}
 
-            let approx_u = (surface.u, range_u).approx_with_cache(
-                tolerance,
-                &mut (),
-                core,
+fn approx_line_on_any_surface(
+    line: &Line<2>,
+    boundary: CurveBoundary<Point<1>>,
+    surface: &SweptCurve,
+    tolerance: impl Into<Tolerance>,
+    geometry: &Geometry,
+) -> Vec<ApproxPoint<1>> {
+    let tolerance = tolerance.into();
+
+    let range_u = CurveBoundary::from(
+        boundary
+            .inner
+            .map(|point_curve| [line.point_from_line_coords(point_curve).u]),
     );
 
+    let SweptCurve { u, .. } = surface;
+    let approx_u = match u {
+        Path::Circle(circle) => approx_circle(circle, range_u, tolerance),
+        Path::Line(line) => approx_line(line),
+    };
+
     let mut points = Vec::new();
     for (u, _) in approx_u {
         let t = (u.t - line.origin().u) / line.direction().u;
-                let point_surface = path.point_from_path_coords([t]);
-                let point_global =
-                    surface.point_from_surface_coords(point_surface);
-                points.push((u, point_global));
+        let point_surface = line.point_from_line_coords([t]);
+        let point_global = convert_point_surface_to_global(
+            surface,
+            point_surface,
+            tolerance,
+            geometry,
+        );
+        points.push(ApproxPoint::new(u, point_global));
     }
 
     points
-        }
-    };
-
-    let points = points
-        .into_iter()
-        .map(|(point_curve, point_global)| {
-            ApproxPoint::new(point_curve, point_global)
-        })
-        .collect();
-    CurveApprox { points }
 }
 
-/// Approximation of [`Curve`], within a specific boundary
+/// Approximation of a [`Curve`], within a specific boundary
+///
+/// The approximation of the curve only includes points _within_ the boundary,
+/// not those _on_ the boundary. Those boundary points are part of half-edge
+/// approximation, which uses and includes curve approximation.
 #[derive(Clone)]
 pub struct CurveApprox {
     /// The points that approximate the curve within the boundary
@@ -146,8 +169,7 @@ impl CurveApprox {
 /// Cache for curve approximations
 #[derive(Default)]
 pub struct CurveApproxCache {
-    inner:
-        BTreeMap<(HandleWrapper<Curve>, CurveBoundary<Point<1>>), CurveApprox>,
+    inner: BTreeMap<(Handle<Curve>, CurveBoundary<Point<1>>), CurveApprox>,
 }
 
 impl CurveApproxCache {
@@ -156,12 +178,12 @@ impl CurveApproxCache {
         handle: &Handle<Curve>,
         boundary: CurveBoundary<Point<1>>,
     ) -> Option<CurveApprox> {
-        let handle = HandleWrapper::from(handle.clone());
-
         if let Some(approx) = self.inner.get(&(handle.clone(), boundary)) {
             return Some(approx.clone());
         }
-        if let Some(approx) = self.inner.get(&(handle, boundary.reverse())) {
+        if let Some(approx) =
+            self.inner.get(&(handle.clone(), boundary.reverse()))
+        {
             return Some(approx.clone().reverse());
         }
 
@@ -174,7 +196,6 @@ impl CurveApproxCache {
         boundary: CurveBoundary<Point<1>>,
         approx: CurveApprox,
     ) -> CurveApprox {
-        let handle = HandleWrapper::from(handle);
         self.inner
             .insert((handle, boundary), approx.clone())
             .unwrap_or(approx)
@@ -185,49 +206,62 @@ impl CurveApproxCache {
 mod tests {
     use std::f64::consts::TAU;
 
+    use fj_math::{Circle, Point, Vector};
     use pretty_assertions::assert_eq;
 
     use crate::{
-        algorithms::approx::{Approx, ApproxPoint},
-        geometry::{CurveBoundary, GlobalPath, SurfaceGeometry, SurfacePath},
-        objects::Curve,
-        operations::insert::Insert,
         Core,
+        algorithms::approx::{
+            ApproxPoint, circle::approx_circle, curve::approx_curve,
+        },
+        geometry::{
+            CurveBoundary, Path,
+            repr::tri_mesh::convert_point_surface_to_global,
+            surfaces::SweptCurve,
+        },
+        operations::build::BuildSurface,
+        topology::Surface,
     };
 
     #[test]
     fn approx_line_on_flat_surface() {
-        let mut core = Core::new();
+        let core = Core::new();
 
-        let curve = Curve::new().insert(&mut core);
-        let (surface_path, boundary) =
-            SurfacePath::line_from_points([[1., 1.], [2., 1.]]);
-        let boundary = CurveBoundary::from(boundary);
         let surface = core.layers.geometry.xz_plane();
+        let (path, boundary) = Path::line_from_points([[1., 1.], [2., 1.]]);
+        let boundary = CurveBoundary::from(boundary);
 
         let tolerance = 1.;
-        let approx = (&curve, surface_path, &surface, boundary)
-            .approx(tolerance, &mut core);
+        let approx = approx_curve(
+            &path,
+            surface,
+            boundary,
+            tolerance,
+            &core.layers.geometry,
+        );
 
         assert_eq!(approx.points, vec![]);
     }
 
     #[test]
     fn approx_line_on_curved_surface_but_not_along_curve() {
-        let mut core = Core::new();
+        let core = Core::new();
 
-        let curve = Curve::new().insert(&mut core);
-        let (surface_path, boundary) =
-            SurfacePath::line_from_points([[1., 1.], [2., 1.]]);
-        let boundary = CurveBoundary::from(boundary);
-        let surface = SurfaceGeometry {
-            u: GlobalPath::circle_from_radius(1.),
-            v: [0., 0., 1.].into(),
+        let surface = SweptCurve {
+            u: Path::circle_from_radius(1.),
+            v: Vector::from([0., 0., 1.]),
         };
+        let (path, boundary) = Path::line_from_points([[1., 1.], [2., 1.]]);
+        let boundary = CurveBoundary::from(boundary);
 
         let tolerance = 1.;
-        let approx = (&curve, surface_path, &surface, boundary)
-            .approx(tolerance, &mut core);
+        let approx = approx_curve(
+            &path,
+            &surface,
+            boundary,
+            tolerance,
+            &core.layers.geometry,
+        );
 
         assert_eq!(approx.points, vec![]);
     }
@@ -236,30 +270,43 @@ mod tests {
     fn approx_line_on_curved_surface_along_curve() {
         let mut core = Core::new();
 
-        let global_path = GlobalPath::circle_from_radius(1.);
-        let curve = Curve::new().insert(&mut core);
-        let surface_path = SurfacePath::line_from_points_with_coords([
+        let circle = Circle::from_center_and_radius(Point::origin(), 1.);
+        let global_path = Path::Circle(circle);
+        let surface_geom = SweptCurve {
+            u: global_path,
+            v: Vector::from([0., 0., 1.]),
+        };
+        let surface = Surface::from_geometry(surface_geom, &mut core);
+        let path = Path::line_from_points_with_coords([
             ([0.], [0., 1.]),
             ([TAU], [TAU, 1.]),
         ]);
         let boundary = CurveBoundary::from([[0.], [TAU]]);
-        let surface = SurfaceGeometry {
-            u: global_path,
-            v: [0., 0., 1.].into(),
-        };
 
         let tolerance = 1.;
-        let approx = (&curve, surface_path, &surface, boundary)
-            .approx(tolerance, &mut core);
+        let approx = approx_curve(
+            &path,
+            &surface_geom,
+            boundary,
+            tolerance,
+            &core.layers.geometry,
+        );
 
-        let expected_approx = (global_path, boundary)
-            .approx(tolerance, &mut core)
+        let expected_approx = approx_circle(&circle, boundary, tolerance)
             .into_iter()
             .map(|(point_local, _)| {
-                let point_surface =
-                    surface_path.point_from_path_coords(point_local);
-                let point_global =
-                    surface.point_from_surface_coords(point_surface);
+                let point_surface = path.point_from_path_coords(point_local);
+                let point_global = convert_point_surface_to_global(
+                    &core
+                        .layers
+                        .geometry
+                        .of_surface_2(&surface)
+                        .unwrap()
+                        .generator,
+                    point_surface,
+                    tolerance,
+                    &core.layers.geometry,
+                );
                 ApproxPoint::new(point_local, point_global)
             })
             .collect::<Vec<_>>();
@@ -270,24 +317,36 @@ mod tests {
     fn approx_circle_on_flat_surface() {
         let mut core = Core::new();
 
-        let curve = Curve::new().insert(&mut core);
-        let surface_path =
-            SurfacePath::circle_from_center_and_radius([0., 0.], 1.);
+        let surface_geom = *core.layers.geometry.xz_plane();
+        let surface = Surface::from_geometry(surface_geom, &mut core);
+        let circle = Circle::from_center_and_radius([0., 0.], 1.);
+        let path = Path::Circle(circle);
         let boundary = CurveBoundary::from([[0.], [TAU]]);
-        let surface = core.layers.geometry.xz_plane();
 
         let tolerance = 1.;
-        let approx = (&curve, surface_path, &surface, boundary)
-            .approx(tolerance, &mut core);
+        let approx = approx_curve(
+            &path,
+            &surface_geom,
+            boundary,
+            tolerance,
+            &core.layers.geometry,
+        );
 
-        let expected_approx = (&surface_path, boundary)
-            .approx(tolerance, &mut core)
+        let expected_approx = approx_circle(&circle, boundary, tolerance)
             .into_iter()
             .map(|(point_local, _)| {
-                let point_surface =
-                    surface_path.point_from_path_coords(point_local);
-                let point_global =
-                    surface.point_from_surface_coords(point_surface);
+                let point_surface = path.point_from_path_coords(point_local);
+                let point_global = convert_point_surface_to_global(
+                    &core
+                        .layers
+                        .geometry
+                        .of_surface_2(&surface)
+                        .unwrap()
+                        .generator,
+                    point_surface,
+                    tolerance,
+                    &core.layers.geometry,
+                );
                 ApproxPoint::new(point_local, point_global)
             })
             .collect::<Vec<_>>();

crates/fj-core/src/algorithms/approx/cycle.rs

@@ -2,38 +2,76 @@
 //!
 //! See [`CycleApprox`].
 
-use fj_math::Segment;
+use fj_interop::Tolerance;
+use fj_math::LineSegment;
 
-use crate::{geometry::SurfaceGeometry, objects::Cycle, Core};
-
-use super::{
-    edge::{HalfEdgeApprox, HalfEdgeApproxCache},
-    Approx, ApproxPoint, Tolerance,
+use crate::{
+    geometry::{CurveBoundary, Geometry},
+    storage::Handle,
+    topology::{Cycle, Surface},
 };
 
-impl Approx for (&Cycle, &SurfaceGeometry) {
-    type Approximation = CycleApprox;
-    type Cache = HalfEdgeApproxCache;
+use super::{
+    ApproxCache, ApproxPoint,
+    half_edge::{HalfEdgeApprox, approx_half_edge},
+    vertex::approx_vertex,
+};
 
-    fn approx_with_cache(
-        self,
+/// Approximate the provided cycle
+pub fn approx_cycle(
+    cycle: &Cycle,
+    surface: &Handle<Surface>,
     tolerance: impl Into<Tolerance>,
-        cache: &mut Self::Cache,
-        core: &mut Core,
-    ) -> Self::Approximation {
-        let (cycle, surface) = self;
+    cache: &mut ApproxCache,
+    geometry: &Geometry,
+) -> CycleApprox {
     let tolerance = tolerance.into();
 
     let half_edges = cycle
         .half_edges()
-            .iter()
-            .map(|half_edge| {
-                (half_edge, surface).approx_with_cache(tolerance, cache, core)
+        .pairs()
+        .map(|(half_edge, next_half_edge)| {
+            let boundary = CurveBoundary {
+                inner: [
+                    geometry
+                        .of_vertex(half_edge.start_vertex())
+                        .unwrap()
+                        .local_on(half_edge.curve())
+                        .unwrap()
+                        .position,
+                    geometry
+                        .of_vertex(next_half_edge.start_vertex())
+                        .unwrap()
+                        .local_on(half_edge.curve())
+                        .unwrap()
+                        .position,
+                ],
+            };
+            let [start_position_curve, _] = boundary.inner;
+
+            let start = approx_vertex(
+                half_edge.start_vertex().clone(),
+                half_edge.curve(),
+                surface,
+                start_position_curve,
+                tolerance,
+                &mut cache.vertex,
+                geometry,
+            );
+
+            approx_half_edge(
+                half_edge,
+                surface,
+                start,
+                boundary,
+                tolerance,
+                &mut cache.curve,
+                geometry,
+            )
         })
         .collect();
 
     CycleApprox { half_edges }
-    }
 }
 
 /// An approximation of a [`Cycle`]
@@ -60,7 +98,7 @@ impl CycleApprox {
     }
 
     /// Construct the segments that approximate the cycle
-    pub fn segments(&self) -> Vec<Segment<3>> {
+    pub fn segments(&self) -> Vec<LineSegment<3>> {
         let mut segments = Vec::new();
 
         for segment in self.points().windows(2) {
@@ -68,8 +106,9 @@ impl CycleApprox {
             // up, once `array_windows` is stable.
             let segment = [&segment[0], &segment[1]];
 
-            segments
-                .push(Segment::from(segment.map(|point| point.global_form)));
+            segments.push(LineSegment::from(
+                segment.map(|point| point.global_form),
+            ));
         }
 
         segments

crates/fj-core/src/algorithms/approx/edge.rs

@@ -1,90 +0,0 @@
-//! Edge approximation
-//!
-//! The approximation of a curve is its first vertex, combined with the
-//! approximation of its curve. The second vertex is left out, as edge
-//! approximations are usually used to build cycle approximations, and this way,
-//! the caller doesn't have to deal with duplicate vertices.
-
-use crate::{
-    geometry::SurfaceGeometry, objects::HalfEdge, storage::Handle, Core,
-};
-
-use super::{
-    curve::CurveApproxCache, vertex::VertexApproxCache, Approx, ApproxPoint,
-    Tolerance,
-};
-
-impl Approx for (&Handle<HalfEdge>, &SurfaceGeometry) {
-    type Approximation = HalfEdgeApprox;
-    type Cache = HalfEdgeApproxCache;
-
-    fn approx_with_cache(
-        self,
-        tolerance: impl Into<Tolerance>,
-        cache: &mut Self::Cache,
-        core: &mut Core,
-    ) -> Self::Approximation {
-        let (half_edge, surface) = self;
-        let tolerance = tolerance.into();
-
-        let start_position_surface = half_edge.start_position();
-        let start_position =
-            match cache.start_position.get(half_edge.start_vertex()) {
-                Some(position) => position,
-                None => {
-                    let position_global = surface
-                        .point_from_surface_coords(start_position_surface);
-                    cache.start_position.insert(
-                        half_edge.start_vertex().clone(),
-                        position_global,
-                    )
-                }
-            };
-
-        let first = ApproxPoint::new(start_position_surface, start_position);
-
-        let rest = {
-            let approx = (
-                half_edge.curve(),
-                core.layers.geometry.of_half_edge(half_edge).path,
-                surface,
-                half_edge.boundary(),
-            )
-                .approx_with_cache(
-                    tolerance,
-                    &mut cache.curve,
-                    core,
-                );
-
-            approx.points.into_iter().map(|point| {
-                let point_surface = core
-                    .layers
-                    .geometry
-                    .of_half_edge(half_edge)
-                    .path
-                    .point_from_path_coords(point.local_form);
-
-                ApproxPoint::new(point_surface, point.global_form)
-            })
-        };
-
-        let mut points = vec![first];
-        points.extend(rest);
-
-        HalfEdgeApprox { points }
-    }
-}
-
-/// An approximation of a [`HalfEdge`]
-#[derive(Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct HalfEdgeApprox {
-    /// The points that approximate the half-edge
-    pub points: Vec<ApproxPoint<2>>,
-}
-
-/// Cache for half-edge approximations
-#[derive(Default)]
-pub struct HalfEdgeApproxCache {
-    start_position: VertexApproxCache,
-    curve: CurveApproxCache,
-}

crates/fj-core/src/algorithms/approx/face.rs

@@ -4,35 +4,35 @@
 
 use std::{collections::BTreeSet, ops::Deref};
 
-use fj_interop::Color;
+use fj_interop::Tolerance;
 
 use crate::{
-    objects::{Face, Handedness, ObjectSet},
-    operations::presentation::GetColor,
+    geometry::Geometry,
+    storage::Handle,
+    topology::{Face, Handedness, ObjectSet},
     validation::ValidationConfig,
-    Core,
 };
 
 use super::{
-    cycle::CycleApprox, edge::HalfEdgeApproxCache, Approx, ApproxPoint,
-    Tolerance,
+    Approx, ApproxCache, ApproxPoint,
+    cycle::{CycleApprox, approx_cycle},
 };
 
 impl Approx for &ObjectSet<Face> {
     type Approximation = BTreeSet<FaceApprox>;
-    type Cache = HalfEdgeApproxCache;
+    type Cache = ApproxCache;
 
     fn approx_with_cache(
         self,
         tolerance: impl Into<Tolerance>,
         cache: &mut Self::Cache,
-        core: &mut Core,
+        geometry: &Geometry,
     ) -> Self::Approximation {
         let tolerance = tolerance.into();
 
         let approx = self
             .into_iter()
-            .map(|face| face.approx_with_cache(tolerance, cache, core))
+            .map(|face| approx_face(face.clone(), tolerance, cache, geometry))
             .collect();
 
         let min_distance = ValidationConfig::default().distinct_min_distance;
@@ -65,68 +65,56 @@ impl Approx for &ObjectSet<Face> {
     }
 }
 
-impl Approx for &Face {
-    type Approximation = FaceApprox;
-    type Cache = HalfEdgeApproxCache;
-
-    fn approx_with_cache(
-        self,
+/// Approximate the provided face
+pub fn approx_face(
+    face: Handle<Face>,
     tolerance: impl Into<Tolerance>,
-        cache: &mut Self::Cache,
-        core: &mut Core,
-    ) -> Self::Approximation {
+    cache: &mut ApproxCache,
+    geometry: &Geometry,
+) -> FaceApprox {
     let tolerance = tolerance.into();
 
-        // Curved faces whose curvature is not fully defined by their edges
-        // are not supported yet. For that reason, we can fully ignore `face`'s
-        // `surface` field and just pass the edges to `Self::for_edges`.
-        //
-        // An example of a curved face that is supported, is the cylinder. Its
-        // curvature is fully defined be the edges (circles) that border it. The
-        // circle approximations are sufficient to triangulate the surface.
-        //
-        // An example of a curved face that is currently not supported, and thus
-        // doesn't need to be handled here, is a sphere. A spherical face would
-        // would need to provide its own approximation, as the edges that bound
-        // it have nothing to do with its curvature.
-
-        let exterior = (
-            self.region().exterior().deref(),
-            &core.layers.geometry.of_surface(self.surface()),
-        )
-            .approx_with_cache(tolerance, cache, core);
+    let exterior = approx_cycle(
+        face.region().exterior().deref(),
+        face.surface(),
+        tolerance,
+        cache,
+        geometry,
+    );
 
     let mut interiors = BTreeSet::new();
-        for cycle in self.region().interiors() {
-            let cycle = (
+    for cycle in face.region().interiors() {
+        let cycle = approx_cycle(
             cycle.deref(),
-                &core.layers.geometry.of_surface(self.surface()),
-            )
-                .approx_with_cache(tolerance, cache, core);
+            face.surface(),
+            tolerance,
+            cache,
+            geometry,
+        );
         interiors.insert(cycle);
     }
 
+    let coord_handedness = face.coord_handedness(geometry);
     FaceApprox {
+        face,
         exterior,
         interiors,
-            color: self.region().get_color(core),
-            coord_handedness: self.coord_handedness(&core.layers.geometry),
-        }
+        coord_handedness,
     }
 }
 
 /// An approximation of a [`Face`]
 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct FaceApprox {
+    /// The [`Face`], that this approximates
+    pub face: Handle<Face>,
+
     /// Approximation of the exterior cycle
     pub exterior: CycleApprox,
 
     /// Approximations of the interior cycles
     pub interiors: BTreeSet<CycleApprox>,
 
-    /// The color of the approximated face
-    pub color: Option<Color>,
-
     /// The handedness of the approximated face's front-side coordinate system
     pub coord_handedness: Handedness,
 }

crates/fj-core/src/algorithms/approx/half_edge.rs

@@ -0,0 +1,70 @@
+//! Half-edge approximation
+//!
+//! See [`HalfEdgeApprox`].
+
+use std::iter;
+
+use fj_interop::Tolerance;
+use fj_math::Point;
+
+use crate::{
+    geometry::{CurveBoundary, Geometry},
+    storage::Handle,
+    topology::{HalfEdge, Surface},
+};
+
+use super::{
+    ApproxPoint,
+    curve::{CurveApproxCache, approx_curve_with_cache},
+};
+
+/// Approximate the provided half-edge
+pub fn approx_half_edge(
+    half_edge: &Handle<HalfEdge>,
+    surface: &Handle<Surface>,
+    start: ApproxPoint<1>,
+    boundary: CurveBoundary<Point<1>>,
+    tolerance: impl Into<Tolerance>,
+    cache: &mut CurveApproxCache,
+    geometry: &Geometry,
+) -> HalfEdgeApprox {
+    let tolerance = tolerance.into();
+
+    let rest = approx_curve_with_cache(
+        half_edge.curve(),
+        surface,
+        boundary,
+        tolerance,
+        cache,
+        geometry,
+    );
+
+    let points = iter::once(start)
+        .chain(rest.points)
+        .map(|point| {
+            let point_surface = geometry
+                .of_curve(half_edge.curve())
+                .unwrap()
+                .local_on(surface)
+                .unwrap()
+                .path
+                .point_from_path_coords(point.local_form);
+
+            ApproxPoint::new(point_surface, point.global_form)
+        })
+        .collect();
+
+    HalfEdgeApprox { points }
+}
+
+/// An approximation of a [`HalfEdge`]
+///
+/// The approximation of a half-edge is its first vertex, combined with the
+/// approximation of its curve. The second vertex is left out, as half-edge
+/// approximations are usually used to build cycle approximations, and this way,
+/// the caller doesn't have to deal with duplicate vertices.
+#[derive(Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct HalfEdgeApprox {
+    /// The points that approximate the half-edge
+    pub points: Vec<ApproxPoint<2>>,
+}

crates/fj-core/src/algorithms/approx/line.rs

@@ -0,0 +1,16 @@
+use fj_math::{Line, Point};
+
+/// Approximate a line
+///
+/// Since curve approximations don't include the approximation boundary itself,
+/// and a line does not require any other points to be fully defined, this
+/// method always returns no points.
+///
+/// The method still exists, to make the code that approximates lines, and thus
+/// this piece of documentation, easy to find for anyone who's looking.
+pub fn approx_line<const D: usize>(
+    line: &Line<D>,
+) -> Vec<(Point<1>, Point<D>)> {
+    let _ = line;
+    Vec::new()
+}

crates/fj-core/src/algorithms/approx/mod.rs

@@ -1,15 +1,16 @@
 //! Approximation of objects
 
-pub mod curve;
 pub mod cycle;
-pub mod edge;
 pub mod face;
-pub mod path;
+pub mod half_edge;
 pub mod shell;
 pub mod sketch;
 pub mod solid;
-pub mod tolerance;
-pub mod vertex;
+
+mod circle;
+mod curve;
+mod line;
+mod vertex;
 
 use std::{
     cmp::Ordering,
@@ -17,11 +18,12 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use curve::CurveApproxCache;
+use fj_interop::Tolerance;
 use fj_math::Point;
+use vertex::VertexApproxCache;
 
-use crate::Core;
-
-pub use self::tolerance::{InvalidTolerance, Tolerance};
+use crate::geometry::Geometry;
 
 /// Approximate an object
 pub trait Approx: Sized {
@@ -38,10 +40,10 @@ pub trait Approx: Sized {
     fn approx(
         self,
         tolerance: impl Into<Tolerance>,
-        core: &mut Core,
+        geometry: &Geometry,
     ) -> Self::Approximation {
         let mut cache = Self::Cache::default();
-        self.approx_with_cache(tolerance, &mut cache, core)
+        self.approx_with_cache(tolerance, &mut cache, geometry)
     }
 
     /// Approximate the object, using the provided cache
@@ -52,10 +54,20 @@ pub trait Approx: Sized {
         self,
         tolerance: impl Into<Tolerance>,
         cache: &mut Self::Cache,
-        core: &mut Core,
+        geometry: &Geometry,
     ) -> Self::Approximation;
 }
 
+/// Cache for half-edge approximations
+#[derive(Default)]
+pub struct ApproxCache {
+    /// Cache for vertex approximations
+    pub vertex: VertexApproxCache,
+
+    /// Cache for curve approximations
+    pub curve: CurveApproxCache,
+}
+
 /// A point from an approximation, with local and global forms
 #[derive(Clone, Copy, Debug)]
 pub struct ApproxPoint<const D: usize> {

crates/fj-core/src/algorithms/approx/path.rs

@@ -1,249 +0,0 @@
-//! # Path approximation
-//!
-//! Since paths are infinite (even circles have an infinite coordinate space,
-//! even though they connect to themselves in global coordinates), a range must
-//! be provided to approximate them. The approximation then returns points
-//! within that range.
-//!
-//! The boundaries of the range are not included in the approximation. This is
-//! done, to give the caller (who knows the boundary anyway) more options on how
-//! to further process the approximation.
-//!
-//! ## Determinism
-//!
-//! Path approximation is carefully designed to produce a deterministic result
-//! for the combination of a given path and a given tolerance, regardless of
-//! what the range is. This is done to prevent invalid meshes from being
-//! generated.
-//!
-//! In specific terms, this means there is an infinite set of points that
-//! approximates a path, and that set is deterministic for a given combination
-//! of path and tolerance. The range that defines where the path is approximated
-//! only influences the result in two ways:
-//!
-//! 1. It controls which points from the infinite set are actually computed.
-//! 2. It defines the order in which the computed points are returned.
-//!
-//! As a result, path approximation is guaranteed to generate points that can
-//! fit together in a valid mesh, no matter which ranges of a path are being
-//! approximated, and how many times.
-
-use std::iter;
-
-use fj_math::{Circle, Point, Scalar, Sign};
-
-use crate::{
-    geometry::{CurveBoundary, GlobalPath, SurfacePath},
-    Core,
-};
-
-use super::{Approx, Tolerance};
-
-impl Approx for (&SurfacePath, CurveBoundary<Point<1>>) {
-    type Approximation = Vec<(Point<1>, Point<2>)>;
-    type Cache = ();
-
-    fn approx_with_cache(
-        self,
-        tolerance: impl Into<Tolerance>,
-        (): &mut Self::Cache,
-        _core: &mut Core,
-    ) -> Self::Approximation {
-        let (path, range) = self;
-
-        match path {
-            SurfacePath::Circle(circle) => {
-                approx_circle(circle, range, tolerance.into())
-            }
-            SurfacePath::Line(_) => vec![],
-        }
-    }
-}
-
-impl Approx for (GlobalPath, CurveBoundary<Point<1>>) {
-    type Approximation = Vec<(Point<1>, Point<3>)>;
-    type Cache = ();
-
-    fn approx_with_cache(
-        self,
-        tolerance: impl Into<Tolerance>,
-        (): &mut Self::Cache,
-        _core: &mut Core,
-    ) -> Self::Approximation {
-        let (path, range) = self;
-
-        match path {
-            GlobalPath::Circle(circle) => {
-                approx_circle(&circle, range, tolerance.into())
-            }
-            GlobalPath::Line(_) => vec![],
-        }
-    }
-}
-
-/// Approximate a circle
-///
-/// `tolerance` specifies how much the approximation is allowed to deviate
-/// from the circle.
-fn approx_circle<const D: usize>(
-    circle: &Circle<D>,
-    boundary: impl Into<CurveBoundary<Point<1>>>,
-    tolerance: Tolerance,
-) -> Vec<(Point<1>, Point<D>)> {
-    let boundary = boundary.into();
-
-    let params = PathApproxParams::for_circle(circle, tolerance);
-    let mut points = Vec::new();
-
-    for point_curve in params.points(boundary) {
-        let point_global = circle.point_from_circle_coords(point_curve);
-        points.push((point_curve, point_global));
-    }
-
-    points
-}
-
-struct PathApproxParams {
-    increment: Scalar,
-}
-
-impl PathApproxParams {
-    pub fn for_circle<const D: usize>(
-        circle: &Circle<D>,
-        tolerance: impl Into<Tolerance>,
-    ) -> Self {
-        let radius = circle.a().magnitude();
-
-        let num_vertices_to_approx_full_circle = Scalar::max(
-            Scalar::PI
-                / (Scalar::ONE - (tolerance.into().inner() / radius)).acos(),
-            3.,
-        )
-        .ceil();
-
-        let increment = Scalar::TAU / num_vertices_to_approx_full_circle;
-
-        Self { increment }
-    }
-
-    pub fn increment(&self) -> Scalar {
-        self.increment
-    }
-
-    pub fn points(
-        &self,
-        boundary: impl Into<CurveBoundary<Point<1>>>,
-    ) -> impl Iterator<Item = Point<1>> + '_ {
-        let boundary = boundary.into();
-
-        let [a, b] = boundary.inner.map(|point| point.t / self.increment());
-        let direction = (b - a).sign();
-        let [min, max] = if a < b { [a, b] } else { [b, a] };
-
-        // We can't generate a point exactly at the boundaries of the range as
-        // part of the approximation. Make sure we stay inside the range.
-        let min = min.floor() + 1.;
-        let max = max.ceil() - 1.;
-
-        let [start, end] = match direction {
-            Sign::Negative => [max, min],
-            Sign::Positive | Sign::Zero => [min, max],
-        };
-
-        let mut i = start;
-        iter::from_fn(move || {
-            let is_finished = match direction {
-                Sign::Negative => i < end,
-                Sign::Positive | Sign::Zero => i > end,
-            };
-
-            if is_finished {
-                return None;
-            }
-
-            let t = self.increment() * i;
-            i += direction.to_scalar();
-
-            Some(Point::from([t]))
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::f64::consts::TAU;
-
-    use fj_math::{Circle, Point, Scalar};
-
-    use crate::algorithms::approx::{path::CurveBoundary, Tolerance};
-
-    use super::PathApproxParams;
-
-    #[test]
-    fn increment_for_circle() {
-        test_increment(1., 0.5, 3.);
-        test_increment(1., 0.1, 7.);
-        test_increment(1., 0.01, 23.);
-
-        fn test_increment(
-            radius: impl Into<Scalar>,
-            tolerance: impl Into<Tolerance>,
-            expected_num_vertices: impl Into<Scalar>,
-        ) {
-            let circle = Circle::from_center_and_radius([0., 0.], radius);
-            let params = PathApproxParams::for_circle(&circle, tolerance);
-
-            let expected_increment = Scalar::TAU / expected_num_vertices;
-            assert_eq!(params.increment(), expected_increment);
-        }
-    }
-
-    #[test]
-    fn points_for_circle() {
-        // At the chosen values for radius and tolerance (see below), the
-        // increment is `PI / 4`, so ~1.57.
-
-        // Empty range
-        let empty: [Scalar; 0] = [];
-        test_path([[0.], [0.]], empty);
-
-        // Ranges contain all generated points. Start is before the first
-        // increment and after the last one in each case.
-        test_path([[0.], [TAU]], [1., 2., 3.]);
-        test_path([[1.], [TAU]], [1., 2., 3.]);
-        test_path([[0.], [TAU - 1.]], [1., 2., 3.]);
-
-        // Here the range is restricted to cut of the first or last increment.
-        test_path([[2.], [TAU]], [2., 3.]);
-        test_path([[0.], [TAU - 2.]], [1., 2.]);
-
-        // And everything again, but in reverse.
-        test_path([[TAU], [0.]], [3., 2., 1.]);
-        test_path([[TAU], [1.]], [3., 2., 1.]);
-        test_path([[TAU - 1.], [0.]], [3., 2., 1.]);
-        test_path([[TAU], [2.]], [3., 2.]);
-        test_path([[TAU - 2.], [0.]], [2., 1.]);
-
-        fn test_path(
-            boundary: impl Into<CurveBoundary<Point<1>>>,
-            expected_coords: impl IntoIterator<Item = impl Into<Scalar>>,
-        ) {
-            // Choose radius and tolerance such, that we need 4 vertices to
-            // approximate a full circle. This is the lowest number that we can
-            // still cover all the edge cases with
-            let radius = 1.;
-            let tolerance = 0.375;
-
-            let circle = Circle::from_center_and_radius([0., 0.], radius);
-            let params = PathApproxParams::for_circle(&circle, tolerance);
-
-            let points = params.points(boundary).collect::<Vec<_>>();
-
-            let expected_points = expected_coords
-                .into_iter()
-                .map(|i| Point::from([params.increment() * i]))
-                .collect::<Vec<_>>();
-            assert_eq!(points, expected_points);
-        }
-    }
-}

crates/fj-core/src/algorithms/approx/shell.rs

@@ -2,20 +2,20 @@
 
 use std::collections::BTreeSet;
 
-use crate::{objects::Shell, Core};
+use crate::{geometry::Geometry, topology::Shell};
 
-use super::{edge::HalfEdgeApproxCache, face::FaceApprox, Approx, Tolerance};
+use super::{Approx, ApproxCache, Tolerance, face::FaceApprox};
 
 impl Approx for &Shell {
     type Approximation = BTreeSet<FaceApprox>;
-    type Cache = HalfEdgeApproxCache;
+    type Cache = ApproxCache;
 
     fn approx_with_cache(
         self,
         tolerance: impl Into<Tolerance>,
         cache: &mut Self::Cache,
-        core: &mut Core,
+        geometry: &Geometry,
     ) -> Self::Approximation {
-        self.faces().approx_with_cache(tolerance, cache, core)
+        self.faces().approx_with_cache(tolerance, cache, geometry)
     }
 }

crates/fj-core/src/algorithms/approx/sketch.rs

@@ -2,19 +2,19 @@
 
 use std::collections::BTreeSet;
 
-use crate::{objects::Sketch, Core};
+use crate::{geometry::Geometry, topology::Sketch};
 
-use super::{edge::HalfEdgeApproxCache, face::FaceApprox, Approx, Tolerance};
+use super::{Approx, ApproxCache, Tolerance, face::FaceApprox};
 
 impl Approx for &Sketch {
     type Approximation = BTreeSet<FaceApprox>;
-    type Cache = HalfEdgeApproxCache;
+    type Cache = ApproxCache;
 
     fn approx_with_cache(
         self,
         _tolerance: impl Into<Tolerance>,
         _cache: &mut Self::Cache,
-        _core: &mut Core,
+        _: &Geometry,
     ) -> Self::Approximation {
         todo!()
     }

crates/fj-core/src/algorithms/approx/solid.rs

@@ -2,25 +2,27 @@
 
 use std::collections::BTreeSet;
 
-use crate::{objects::Solid, Core};
+use crate::{geometry::Geometry, topology::Solid};
 
-use super::{edge::HalfEdgeApproxCache, face::FaceApprox, Approx, Tolerance};
+use super::{Approx, ApproxCache, Tolerance, face::FaceApprox};
 
 impl Approx for &Solid {
     type Approximation = BTreeSet<FaceApprox>;
-    type Cache = HalfEdgeApproxCache;
+    type Cache = ApproxCache;
 
     fn approx_with_cache(
         self,
         tolerance: impl Into<Tolerance>,
         cache: &mut Self::Cache,
-        core: &mut Core,
+        geometry: &Geometry,
     ) -> Self::Approximation {
         let tolerance = tolerance.into();
 
         self.shells()
             .iter()
-            .flat_map(|shell| shell.approx_with_cache(tolerance, cache, core))
+            .flat_map(|shell| {
+                shell.approx_with_cache(tolerance, cache, geometry)
+            })
             .collect()
     }
 }

crates/fj-core/src/algorithms/approx/vertex.rs

@@ -1,24 +1,59 @@
-//! Vertex approximation
-
 use std::collections::BTreeMap;
 
 use fj_math::Point;
 
 use crate::{
-    objects::Vertex,
-    storage::{Handle, HandleWrapper},
+    geometry::{Geometry, repr::tri_mesh::convert_point_surface_to_global},
+    storage::Handle,
+    topology::{Curve, Surface, Vertex},
 };
 
+use super::{ApproxPoint, Tolerance};
+
+/// # Approximate a vertex position
+pub fn approx_vertex(
+    vertex: Handle<Vertex>,
+    curve: &Handle<Curve>,
+    surface: &Handle<Surface>,
+    position_curve: Point<1>,
+    tolerance: impl Into<Tolerance>,
+    cache: &mut VertexApproxCache,
+    geometry: &Geometry,
+) -> ApproxPoint<1> {
+    let position_surface = geometry
+        .of_curve(curve)
+        .unwrap()
+        .local_on(surface)
+        .unwrap()
+        .path
+        .point_from_path_coords(position_curve);
+
+    let position_global = match cache.get(&vertex) {
+        Some(position) => position,
+        None => {
+            let position_global = convert_point_surface_to_global(
+                &geometry.of_surface_2(surface).unwrap().generator,
+                position_surface,
+                tolerance,
+                geometry,
+            );
+            cache.insert(vertex, position_global)
+        }
+    };
+
+    ApproxPoint::new(position_curve, position_global)
+}
+
 /// Cache for vertex approximations
 #[derive(Default)]
 pub struct VertexApproxCache {
-    inner: BTreeMap<HandleWrapper<Vertex>, Point<3>>,
+    inner: BTreeMap<Handle<Vertex>, Point<3>>,
 }
 
 impl VertexApproxCache {
     /// Get an approximated vertex from the cache
     pub fn get(&self, handle: &Handle<Vertex>) -> Option<Point<3>> {
-        self.inner.get(&handle.clone().into()).cloned()
+        self.inner.get(handle).cloned()
     }
 
     /// Insert an approximated vertex into the cache
@@ -27,8 +62,6 @@ impl VertexApproxCache {
         handle: Handle<Vertex>,
         position: Point<3>,
     ) -> Point<3> {
-        self.inner
-            .insert(handle.clone().into(), position)
-            .unwrap_or(position)
+        self.inner.insert(handle, position).unwrap_or(position)
     }
 }

crates/fj-core/src/algorithms/bounding_volume/cycle.rs

@@ -1,14 +1,21 @@
 use fj_math::Aabb;
 
-use crate::{geometry::Geometry, objects::Cycle};
+use crate::{
+    geometry::Geometry,
+    storage::Handle,
+    topology::{Cycle, Surface},
+};
+
+impl super::BoundingVolume<2> for (&Cycle, &Handle<Surface>) {
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<2>> {
+        let (cycle, surface) = self;
 
-impl super::BoundingVolume<2> for Cycle {
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<2>> {
         let mut aabb: Option<Aabb<2>> = None;
 
-        for edge in self.half_edges() {
-            let new_aabb =
-                edge.aabb(geometry).expect("`Edge` can always compute AABB");
+        for (half_edge, half_edge_next) in cycle.half_edges().pairs() {
+            let new_aabb = (half_edge, half_edge_next.start_vertex(), surface)
+                .aabb(geometry)
+                .expect("`HalfEdge` can always compute AABB");
             aabb = Some(aabb.map_or(new_aabb, |aabb| aabb.merged(&new_aabb)));
         }
 

crates/fj-core/src/algorithms/bounding_volume/edge.rs

@@ -1,36 +0,0 @@
-use fj_math::{Aabb, Vector};
-
-use crate::{
-    geometry::{Geometry, SurfacePath},
-    objects::HalfEdge,
-    storage::Handle,
-};
-
-impl super::BoundingVolume<2> for Handle<HalfEdge> {
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<2>> {
-        match geometry.of_half_edge(self).path {
-            SurfacePath::Circle(circle) => {
-                // Just calculate the AABB of the whole circle. This is not the
-                // most precise, but it should do for now.
-
-                let center_to_min_max =
-                    Vector::from([circle.radius(), circle.radius()]);
-
-                Some(Aabb {
-                    min: circle.center() - center_to_min_max,
-                    max: circle.center() + center_to_min_max,
-                })
-            }
-            SurfacePath::Line(_) => {
-                let points = self.boundary().inner.map(|point_curve| {
-                    geometry
-                        .of_half_edge(self)
-                        .path
-                        .point_from_path_coords(point_curve)
-                });
-
-                Some(Aabb::<2>::from_points(points))
-            }
-        }
-    }
-}

crates/fj-core/src/algorithms/bounding_volume/face.rs

@@ -1,33 +1,47 @@
-use fj_math::Aabb;
+use std::ops::Deref;
+
+use fj_interop::Tolerance;
+use fj_math::{Aabb, Vector};
 
 use crate::{
-    geometry::{Geometry, GlobalPath},
-    objects::Face,
+    geometry::{
+        Geometry, repr::tri_mesh::convert_point_surface_to_global,
+        traits::GenTriMesh,
+    },
+    topology::Face,
 };
 
-impl super::BoundingVolume<3> for Face {
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<3>> {
-        self.region().exterior().aabb(geometry).map(|aabb2| {
-            let surface = geometry.of_surface(self.surface());
+impl super::BoundingVolume<3> for &Face {
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<3>> {
+        // A bounding volume must include the body it bounds, but does not need
+        // to match it precisely. So it's okay, if it's a bit larger.
+        //
+        // Let's just choose a reasonable tolerance value here, that we can use
+        // to enlarge any AABBs we use in this method as necessary.
+        let tolerance = Tolerance::from_scalar(0.001)
+            .expect("Tolerance provided is larger than zero");
 
-            match surface.u {
-                GlobalPath::Circle(circle) => {
-                    // This is not the most precise way to calculate the AABB,
-                    // doing it for the whole circle, but it should do.
+        (self.region().exterior().deref(), self.surface())
+            .aabb(geometry)
+            .map(|aabb2| {
+                let surface =
+                    &geometry.of_surface_2(self.surface()).unwrap().generator;
+                let tri_mesh =
+                    surface.generate_tri_mesh(aabb2, tolerance, geometry);
+                let tri_mesh = tri_mesh.into_iter().map(|point| {
+                    convert_point_surface_to_global(
+                        surface, point, tolerance, geometry,
+                    )
+                });
 
-                    let aabb_bottom = circle.aabb();
-                    let aabb_top = Aabb {
-                        min: aabb_bottom.min + surface.v,
-                        max: aabb_bottom.max + surface.v,
-                    };
+                let mut aabb3 = Aabb::<3>::from_points(tri_mesh);
 
-                    aabb_bottom.merged(&aabb_top)
-                }
-                GlobalPath::Line(_) => Aabb {
-                    min: surface.point_from_surface_coords(aabb2.min),
-                    max: surface.point_from_surface_coords(aabb2.max),
-                },
-            }
+                let offset = Vector::from([tolerance.inner(); 3]);
+
+                aabb3.min -= offset;
+                aabb3.max += offset;
+
+                aabb3
             })
     }
 }

crates/fj-core/src/algorithms/bounding_volume/half_edge.rs

@@ -0,0 +1,52 @@
+use fj_math::{Aabb, Vector};
+
+use crate::{
+    geometry::{Geometry, Path},
+    storage::Handle,
+    topology::{HalfEdge, Surface, Vertex},
+};
+
+impl super::BoundingVolume<2>
+    for (&Handle<HalfEdge>, &Handle<Vertex>, &Handle<Surface>)
+{
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<2>> {
+        let (half_edge, end_vertex, surface) = self;
+
+        let path = geometry
+            .of_curve(half_edge.curve())
+            .unwrap()
+            .local_on(surface)
+            .unwrap()
+            .path;
+
+        match path {
+            Path::Circle(circle) => {
+                // Just calculate the AABB of the whole circle. This is not the
+                // most precise, but it should do for now.
+
+                let center_to_min_max =
+                    Vector::from([circle.radius(), circle.radius()]);
+
+                Some(Aabb {
+                    min: circle.center() - center_to_min_max,
+                    max: circle.center() + center_to_min_max,
+                })
+            }
+            Path::Line(_) => {
+                let points =
+                    [half_edge.start_vertex(), end_vertex].map(|vertex| {
+                        let point_curve = geometry
+                            .of_vertex(vertex)
+                            .unwrap()
+                            .local_on(half_edge.curve())
+                            .unwrap()
+                            .position;
+
+                        path.point_from_path_coords(point_curve)
+                    });
+
+                Some(Aabb::<2>::from_points(points))
+            }
+        }
+    }
+}

crates/fj-core/src/algorithms/bounding_volume/mod.rs

@@ -1,8 +1,8 @@
 //! Compute a bounding volume for an object
 
 mod cycle;
-mod edge;
 mod face;
+mod half_edge;
 mod shell;
 mod solid;
 
@@ -15,5 +15,5 @@ pub trait BoundingVolume<const D: usize> {
     /// Compute an axis-aligned bounding box (AABB)
     ///
     /// Return `None`, if no AABB can be computed (if the object is empty).
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<D>>;
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<D>>;
 }

crates/fj-core/src/algorithms/bounding_volume/shell.rs

@@ -1,9 +1,9 @@
 use fj_math::Aabb;
 
-use crate::{geometry::Geometry, objects::Shell};
+use crate::{geometry::Geometry, topology::Shell};
 
-impl super::BoundingVolume<3> for Shell {
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<3>> {
+impl super::BoundingVolume<3> for &Shell {
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<3>> {
         let mut aabb: Option<Aabb<3>> = None;
 
         for face in self.faces() {

crates/fj-core/src/algorithms/bounding_volume/solid.rs

@@ -1,9 +1,9 @@
 use fj_math::Aabb;
 
-use crate::{geometry::Geometry, objects::Solid};
+use crate::{geometry::Geometry, topology::Solid};
 
-impl super::BoundingVolume<3> for Solid {
-    fn aabb(&self, geometry: &Geometry) -> Option<Aabb<3>> {
+impl super::BoundingVolume<3> for &Solid {
+    fn aabb(self, geometry: &Geometry) -> Option<Aabb<3>> {
         let mut aabb: Option<Aabb<3>> = None;
 
         for shell in self.shells() {

crates/fj-core/src/algorithms/intersect/line_segment.rs

@@ -1,6 +1,6 @@
-use fj_math::{Aabb, Line, Point, Scalar, Segment, Vector};
+use fj_math::{Aabb, Line, LineSegment, Point, Scalar, Vector};
 
-/// An intersection between a [`Line`] and a [`Segment`]
+/// An intersection between a [`Line`] and a [`LineSegment`]
 #[derive(Debug, Eq, PartialEq)]
 pub enum LineSegmentIntersection {
     /// Line and segment intersect at a point
@@ -17,12 +17,12 @@ pub enum LineSegmentIntersection {
 }
 
 impl LineSegmentIntersection {
-    /// Determine the intersection between a [`Line`] and a [`Segment`]
-    pub fn compute(line: &Line<2>, segment: &Segment<2>) -> Option<Self> {
+    /// Determine the intersection between a [`Line`] and a [`LineSegment`]
+    pub fn compute(line: &Line<2>, segment: &LineSegment<2>) -> Option<Self> {
         // Algorithm adapted from Real-Time Collision Detection by Christer
         // Ericson. See section 5.1.9.1, 2D Segment Intersection.
 
-        let [a, b] = segment.points();
+        let [a, b] = segment.points;
 
         // Find vector that is orthogonal to `segment`.
         let n = {
@@ -40,7 +40,7 @@ impl LineSegmentIntersection {
                 // `line` and `segment` are not just parallel, but coincident!
                 return Some(Self::Coincident {
                     points_on_line: segment
-                        .points()
+                        .points
                         .map(|point| line.point_to_line_coords(point)),
                 });
             }
@@ -52,7 +52,7 @@ impl LineSegmentIntersection {
         // line defined by `segment`'s points.
         let t = n_dot_origin / n_dot_direction;
 
-        let point_is_on_segment = Aabb::<2>::from_points(segment.points())
+        let point_is_on_segment = Aabb::<2>::from_points(segment.points)
             .contains(line.point_from_line_coords([t]));
         if !point_is_on_segment {
             return None;
@@ -66,7 +66,7 @@ impl LineSegmentIntersection {
 
 #[cfg(test)]
 mod tests {
-    use fj_math::{Line, Point, Scalar, Segment, Vector};
+    use fj_math::{Line, LineSegment, Point, Scalar, Vector};
 
     use super::LineSegmentIntersection;
 
@@ -78,7 +78,7 @@ mod tests {
         assert_eq!(
             LineSegmentIntersection::compute(
                 &line,
-                &Segment::from_points([[1., -1.], [1., 1.]]),
+                &LineSegment::from([[1., -1.], [1., 1.]]),
             ),
             Some(LineSegmentIntersection::Point {
                 point_on_line: Point::from([Scalar::ONE])
@@ -94,7 +94,7 @@ mod tests {
         assert_eq!(
             LineSegmentIntersection::compute(
                 &line,
-                &Segment::from_points([[1., 0.], [2., 0.]]),
+                &LineSegment::from([[1., 0.], [2., 0.]]),
             ),
             Some(LineSegmentIntersection::Coincident {
                 points_on_line: [Point::from([1.]), Point::from([2.])],
@@ -110,7 +110,7 @@ mod tests {
         assert_eq!(
             LineSegmentIntersection::compute(
                 &line,
-                &Segment::from_points([[1., 1.], [1., 2.]]),
+                &LineSegment::from([[1., 1.], [1., 2.]]),
             ),
             None,
         );
@@ -124,7 +124,7 @@ mod tests {
         assert_eq!(
             LineSegmentIntersection::compute(
                 &line,
-                &Segment::from_points([[1., -2.], [1., -1.]]),
+                &LineSegment::from([[1., -2.], [1., -1.]]),
             ),
             None,
         );
@@ -138,7 +138,7 @@ mod tests {
         assert_eq!(
             LineSegmentIntersection::compute(
                 &line,
-                &Segment::from_points([[-1., 1.], [1., 1.]]),
+                &LineSegment::from([[-1., 1.], [1., 1.]]),
             ),
             None,
         );

crates/fj-core/src/algorithms/intersect/ray_segment.rs

@@ -1,16 +1,16 @@
 //! Intersection between a ray and a line segment in 2D
 
-use fj_math::Segment;
+use fj_math::LineSegment;
 
 use super::{HorizontalRayToTheRight, Intersect};
 
-impl Intersect for (&HorizontalRayToTheRight<2>, &Segment<2>) {
+impl Intersect for (&HorizontalRayToTheRight<2>, &LineSegment<2>) {
     type Intersection = RaySegmentIntersection;
 
     fn intersect(self) -> Option<Self::Intersection> {
         let (ray, segment) = self;
 
-        let [a, b] = segment.points();
+        let [a, b] = segment.points;
         let [lower, upper] = if a.v <= b.v { [a, b] } else { [b, a] };
         let [left, right] = if a.u <= b.u { [a, b] } else { [b, a] };
 
@@ -115,7 +115,7 @@ pub enum RaySegmentIntersection {
 
 #[cfg(test)]
 mod tests {
-    use fj_math::Segment;
+    use fj_math::LineSegment;
 
     use crate::algorithms::intersect::Intersect;
 
@@ -125,9 +125,9 @@ mod tests {
     fn ray_is_left_of_segment() {
         let ray = HorizontalRayToTheRight::from([0., 2.]);
 
-        let below = Segment::from([[1., 0.], [1., 1.]]);
-        let above = Segment::from([[1., 3.], [1., 4.]]);
-        let same_level = Segment::from([[1., 1.], [1., 3.]]);
+        let below = LineSegment::from([[1., 0.], [1., 1.]]);
+        let above = LineSegment::from([[1., 3.], [1., 4.]]);
+        let same_level = LineSegment::from([[1., 1.], [1., 3.]]);
 
         assert!((&ray, &below).intersect().is_none());
         assert!((&ray, &above).intersect().is_none());
@@ -141,7 +141,7 @@ mod tests {
     fn ray_is_right_of_segment() {
         let ray = HorizontalRayToTheRight::from([1., 2.]);
 
-        let same_level = Segment::from([[0., 1.], [0., 3.]]);
+        let same_level = LineSegment::from([[0., 1.], [0., 3.]]);
         assert!((&ray, &same_level).intersect().is_none());
     }
 
@@ -149,11 +149,11 @@ mod tests {
     fn ray_overlaps_with_segment_along_x_axis() {
         let ray = HorizontalRayToTheRight::from([1., 1.]);
 
-        let no_hit = Segment::from([[0., 0.], [2., 3.]]);
+        let no_hit = LineSegment::from([[0., 0.], [2., 3.]]);
 
-        let hit_segment = Segment::from([[0., 0.], [3., 2.]]);
-        let hit_upper = Segment::from([[0., 0.], [2., 1.]]);
-        let hit_lower = Segment::from([[0., 2.], [2., 1.]]);
+        let hit_segment = LineSegment::from([[0., 0.], [3., 2.]]);
+        let hit_upper = LineSegment::from([[0., 0.], [2., 1.]]);
+        let hit_lower = LineSegment::from([[0., 2.], [2., 1.]]);
 
         assert!((&ray, &no_hit).intersect().is_none());
         assert!(matches!(
@@ -174,9 +174,9 @@ mod tests {
     fn ray_starts_on_segment() {
         let ray = HorizontalRayToTheRight::from([1., 1.]);
 
-        let hit_segment = Segment::from([[0., 0.], [2., 2.]]);
-        let hit_upper = Segment::from([[0., 0.], [1., 1.]]);
-        let hit_lower = Segment::from([[1., 1.], [2., 2.]]);
+        let hit_segment = LineSegment::from([[0., 0.], [2., 2.]]);
+        let hit_upper = LineSegment::from([[0., 0.], [1., 1.]]);
+        let hit_lower = LineSegment::from([[1., 1.], [2., 2.]]);
 
         assert!(matches!(
             (&ray, &hit_segment).intersect(),
@@ -196,8 +196,8 @@ mod tests {
     fn ray_and_segment_are_parallel_and_on_same_level() {
         let ray = HorizontalRayToTheRight::from([2., 0.]);
 
-        let left = Segment::from([[0., 0.], [1., 0.]]);
-        let right = Segment::from([[3., 0.], [4., 0.]]);
+        let left = LineSegment::from([[0., 0.], [1., 0.]]);
+        let right = LineSegment::from([[3., 0.], [4., 0.]]);
 
         assert!((&ray, &left).intersect().is_none());
         assert!(matches!(
@@ -210,9 +210,9 @@ mod tests {
     fn ray_starts_on_parallel_segment() {
         let ray = HorizontalRayToTheRight::from([2., 0.]);
 
-        let left = Segment::from([[0., 0.], [2., 0.]]);
-        let overlapping = Segment::from([[1., 0.], [3., 0.]]);
-        let right = Segment::from([[2., 0.], [4., 0.]]);
+        let left = LineSegment::from([[0., 0.], [2., 0.]]);
+        let overlapping = LineSegment::from([[1., 0.], [3., 0.]]);
+        let right = LineSegment::from([[2., 0.], [4., 0.]]);
 
         assert!(matches!(
             (&ray, &left).intersect(),

crates/fj-core/src/algorithms/triangulate/delaunay.rs

@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use fj_math::{Point, Scalar, Triangle, Winding};
 use spade::HasPosition;
 
-use crate::{algorithms::approx::cycle::CycleApprox, objects::Handedness};
+use crate::{algorithms::approx::cycle::CycleApprox, topology::Handedness};
 
 /// Create a Delaunay triangulation of all points
 pub fn triangulate(
@@ -47,20 +47,28 @@ pub fn triangulate(
     let mut triangles = Vec::new();
     for triangle in triangulation.inner_faces() {
         let [v0, v1, v2] = triangle.vertices().map(|vertex| *vertex.data());
-        let triangle_winding = Triangle::<2>::from_points([
+        let triangle = Triangle::<2>::from_points([
             v0.point_surface,
             v1.point_surface,
             v2.point_surface,
-        ])
-        .expect("invalid triangle")
-        .winding();
+        ]);
+        assert!(
+            triangle.is_valid(),
+            "Expecting triangles created by triangulation to be valid.",
+        );
 
         let required_winding = match coord_handedness {
             Handedness::LeftHanded => Winding::Cw,
             Handedness::RightHanded => Winding::Ccw,
         };
+        let Some(actual_winding) = triangle.winding() else {
+            unreachable!(
+                "Just asserted that the triangle is valid. Therefore it must \
+                have a winding."
+            );
+        };
 
-        let triangle = if triangle_winding == required_winding {
+        let triangle = if actual_winding == required_winding {
             [v0, v1, v2]
         } else {
             [v0, v2, v1]

crates/fj-core/src/algorithms/triangulate/mod.rs

@@ -3,20 +3,19 @@
 mod delaunay;
 mod polygon;
 
-use fj_interop::Mesh;
-use fj_math::Point;
+use fj_interop::{MeshTriangle, Tolerance, TriMesh};
 
-use crate::Core;
+use crate::{Core, operations::presentation::GetColor};
 
 use self::polygon::Polygon;
 
-use super::approx::{face::FaceApprox, Approx, Tolerance};
+use super::approx::{Approx, face::FaceApprox};
 
 /// Triangulate a shape
 pub trait Triangulate: Sized {
     /// Triangulate the shape
-    fn triangulate(self, core: &mut Core) -> Mesh<Point<3>> {
-        let mut mesh = Mesh::new();
+    fn triangulate(self, core: &mut Core) -> TriMesh {
+        let mut mesh = TriMesh::new();
         self.triangulate_into_mesh(&mut mesh, core);
         mesh
     }
@@ -25,7 +24,7 @@ pub trait Triangulate: Sized {
     ///
     /// This is a low-level method, intended for implementation of
     /// `Triangulate`. Most callers should prefer [`Triangulate::triangulate`].
-    fn triangulate_into_mesh(self, mesh: &mut Mesh<Point<3>>, core: &mut Core);
+    fn triangulate_into_mesh(self, mesh: &mut TriMesh, core: &mut Core);
 }
 
 impl<T> Triangulate for (T, Tolerance)
@@ -33,10 +32,10 @@ where
     T: Approx,
     T::Approximation: IntoIterator<Item = FaceApprox>,
 {
-    fn triangulate_into_mesh(self, mesh: &mut Mesh<Point<3>>, core: &mut Core) {
+    fn triangulate_into_mesh(self, mesh: &mut TriMesh, core: &mut Core) {
         let (approx, tolerance) = self;
 
-        let approx = approx.approx(tolerance, core);
+        let approx = approx.approx(tolerance, &core.layers.geometry);
 
         for approx in approx {
             approx.triangulate_into_mesh(mesh, core);
@@ -45,11 +44,7 @@ where
 }
 
 impl Triangulate for FaceApprox {
-    fn triangulate_into_mesh(
-        self,
-        mesh: &mut Mesh<Point<3>>,
-        _core: &mut Core,
-    ) {
+    fn triangulate_into_mesh(self, mesh: &mut TriMesh, core: &mut Core) {
         let face_as_polygon = Polygon::new()
             .with_exterior(
                 self.exterior
@@ -69,28 +64,35 @@ impl Triangulate for FaceApprox {
                 .contains_triangle(triangle.map(|point| point.point_surface))
         });
 
-        let color = self.color.unwrap_or_default();
+        let color = self.face.region().get_color(core).unwrap_or_default();
 
         for triangle in triangles {
             let points = triangle.map(|point| point.point_global);
-            mesh.push_triangle(points, color);
+            mesh.triangles.push(MeshTriangle {
+                inner: points.into(),
+                is_internal: false,
+                color,
+            });
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use fj_interop::Mesh;
+    use fj_interop::{Tolerance, TriMesh};
     use fj_math::{Point, Scalar};
 
     use crate::{
-        algorithms::approx::{Approx, Tolerance},
-        objects::{Cycle, Face},
+        Core,
+        algorithms::approx::{ApproxCache, face::approx_face},
+        geometry::repr::tri_mesh::convert_point_surface_to_global,
         operations::{
             build::{BuildCycle, BuildFace},
+            insert::Insert,
             update::{UpdateFace, UpdateRegion},
         },
-        Core,
+        storage::Handle,
+        topology::{Cycle, Face},
     };
 
     use super::Triangulate;
@@ -104,17 +106,19 @@ mod tests {
         let c = [2., 2.];
         let d = [0., 1.];
 
-        let face =
-            Face::unbound(core.layers.objects.surfaces.xy_plane(), &mut core)
+        let surface = core.layers.topology.surfaces.xy_plane();
+
+        let face = Face::unbound(surface.clone(), &mut core)
             .update_region(
                 |region, core| {
                     region.update_exterior(
-                            |_, core| Cycle::polygon([a, b, c, d], core),
+                        |_, core| Cycle::polygon([a, b, c, d], surface, core),
                         core,
                     )
                 },
                 &mut core,
-                );
+            )
+            .insert(&mut core);
 
         let a = Point::from(a).to_xyz();
         let b = Point::from(b).to_xyz();
@@ -145,52 +149,50 @@ mod tests {
         let g = [3., 3.];
         let h = [3., 1.];
 
-        let surface = core.layers.objects.surfaces.xy_plane();
+        let surface = core.layers.topology.surfaces.xy_plane();
 
-        let face = Face::unbound(surface.clone(), &mut core).update_region(
+        let face = Face::unbound(surface.clone(), &mut core)
+            .update_region(
                 |region, core| {
                     region
                         .update_exterior(
-                        |_, core| Cycle::polygon([a, b, c, d], core),
+                            |_, core| {
+                                Cycle::polygon(
+                                    [a, b, c, d],
+                                    surface.clone(),
+                                    core,
+                                )
+                            },
+                            core,
+                        )
+                        .add_interiors(
+                            [Cycle::polygon(
+                                [e, f, g, h],
+                                surface.clone(),
+                                core,
+                            )],
                             core,
                         )
-                    .add_interiors([Cycle::polygon([e, f, g, h], core)], core)
                 },
                 &mut core,
-        );
+            )
+            .insert(&mut core);
 
         let triangles = triangulate(face, &mut core)?;
 
-        let a = core
+        let [a, b, e, f, g, h] = [a, b, e, f, g, h].map(|point| {
+            convert_point_surface_to_global(
+                &core
                     .layers
                     .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(a);
-        let b = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(b);
-        let e = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(e);
-        let f = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(f);
-        let g = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(g);
-        let h = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(h);
+                    .of_surface_2(&surface)
+                    .unwrap()
+                    .generator,
+                point,
+                core.tolerance(),
+                &core.layers.geometry,
+            )
+        });
 
         // Let's test that some correct triangles are present. We don't need to
         // test them all.
@@ -234,45 +236,41 @@ mod tests {
         let d = [1., 1.];
         let e = [0., 9.];
 
-        let surface = core.layers.objects.surfaces.xy_plane();
+        let surface = core.layers.topology.surfaces.xy_plane();
 
-        let face = Face::unbound(surface.clone(), &mut core).update_region(
+        let face = Face::unbound(surface.clone(), &mut core)
+            .update_region(
                 |region, core| {
                     region.update_exterior(
-                    |_, core| Cycle::polygon([a, b, c, d, e], core),
+                        |_, core| {
+                            Cycle::polygon(
+                                [a, b, c, d, e],
+                                surface.clone(),
+                                core,
+                            )
+                        },
                         core,
                     )
                 },
                 &mut core,
-        );
+            )
+            .insert(&mut core);
 
         let triangles = triangulate(face, &mut core)?;
 
-        let a = core
+        let [a, b, c, d, e] = [a, b, c, d, e].map(|point| {
+            convert_point_surface_to_global(
+                &core
                     .layers
                     .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(a);
-        let b = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(b);
-        let c = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(c);
-        let d = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(d);
-        let e = core
-            .layers
-            .geometry
-            .of_surface(&surface)
-            .point_from_surface_coords(e);
+                    .of_surface_2(&surface)
+                    .unwrap()
+                    .generator,
+                point,
+                core.tolerance(),
+                &core.layers.geometry,
+            )
+        });
 
         assert!(triangles.contains_triangle([a, b, d]));
         assert!(triangles.contains_triangle([a, d, e]));
@@ -282,10 +280,16 @@ mod tests {
     }
 
     fn triangulate(
-        face: Face,
+        face: Handle<Face>,
         core: &mut Core,
-    ) -> anyhow::Result<Mesh<Point<3>>> {
+    ) -> anyhow::Result<TriMesh> {
         let tolerance = Tolerance::from_scalar(Scalar::ONE)?;
-        Ok(face.approx(tolerance, core).triangulate(core))
+        Ok(approx_face(
+            face,
+            tolerance,
+            &mut ApproxCache::default(),
+            &core.layers.geometry,
+        )
+        .triangulate(core))
     }
 }

crates/fj-core/src/algorithms/triangulate/polygon.rs

@@ -1,8 +1,8 @@
 use fj_interop::ext::SliceExt;
-use fj_math::{Point, PolyChain, Segment, Triangle};
+use fj_math::{LineSegment, Point, PolyChain, Triangle};
 
 use crate::algorithms::intersect::{
-    ray_segment::RaySegmentIntersection, HorizontalRayToTheRight, Intersect,
+    HorizontalRayToTheRight, Intersect, ray_segment::RaySegmentIntersection,
 };
 
 #[derive(Default)]
@@ -42,12 +42,12 @@ impl Polygon {
     }
 
     pub fn contains_triangle(&self, triangle: impl Into<Triangle<2>>) -> bool {
-        let [a, b, c] = triangle.into().points();
+        let [a, b, c] = triangle.into().points;
 
         let mut might_be_hole = true;
 
         for &edge in [a, b, c, a].as_slice().array_windows_ext() {
-            let edge = Segment::from(edge);
+            let edge = LineSegment::from(edge);
 
             let is_exterior_edge = self.contains_exterior_edge(edge);
             let is_interior_edge = self.contains_interior_edge(edge);
@@ -90,12 +90,12 @@ impl Polygon {
         true
     }
 
-    fn contains_exterior_edge(&self, edge: Segment<2>) -> bool {
+    fn contains_exterior_edge(&self, edge: LineSegment<2>) -> bool {
         self.exterior.segments().contains(&edge)
             || self.exterior.segments().contains(&edge.reverse())
     }
 
-    fn contains_interior_edge(&self, edge: Segment<2>) -> bool {
+    fn contains_interior_edge(&self, edge: LineSegment<2>) -> bool {
         let mut contains = false;
 
         for chain in &self.interiors {

crates/fj-core/src/core.rs

@@ -2,26 +2,39 @@
 //!
 //! See [`Core`].
 
+use fj_interop::Tolerance;
+
 use crate::{layers::Layers, validation::ValidationConfig};
 
 /// An instance of the Fornjot core
 ///
 /// This is the main entry point to `fj-core`'s API.
-#[derive(Default)]
 pub struct Core {
     /// The layers of data that make up the state of a core instance
     pub layers: Layers,
 }
 
 impl Core {
-    /// Construct an instance of `Instance`
+    /// Construct an instance of `Core`
     pub fn new() -> Self {
-        Self::default()
+        let layers = Layers::default();
+        Self { layers }
     }
 
-    /// Construct an instance of `Instance`, using the provided configuration
+    /// Construct an instance of `Core`, using the provided configuration
     pub fn with_validation_config(config: ValidationConfig) -> Self {
         let layers = Layers::with_validation_config(config);
         Self { layers }
     }
+
+    /// Access the tolerance value used for intermediate geometry representation
+    pub fn tolerance(&self) -> Tolerance {
+        self.layers.validation.config.tolerance
+    }
+}
+
+impl Default for Core {
+    fn default() -> Self {
+        Self::new()
+    }
 }

crates/fj-core/src/geometry/boundary.rs

@@ -1,11 +1,11 @@
 use std::{
-    cmp::{self, Ordering},
+    cmp::Ordering,
     hash::{Hash, Hasher},
 };
 
 use fj_math::Point;
 
-use crate::{objects::Vertex, storage::HandleWrapper};
+use crate::{storage::Handle, topology::Vertex};
 
 /// A boundary on a curve
 ///
@@ -52,134 +52,11 @@ impl<T: CurveBoundaryElement> CurveBoundary<T> {
     }
 }
 
-// Technically, these methods could be implemented for all
-// `CurveBoundaryElement`s, but that would be misleading. While
-// `HandleWrapper<Vertex>` implements `Ord`, which is useful for putting it (and
-// by extension, `CurveBoundary<Vertex>`) into `BTreeMap`s, this `Ord`
-// implementation doesn't actually define the geometrically meaningful ordering
-// that the following methods rely on.
-impl CurveBoundary<Point<1>> {
-    /// Indicate whether the boundary is empty
-    pub fn is_empty(&self) -> bool {
-        let [min, max] = &self.inner;
-        min >= max
+impl Default for CurveBoundary<Point<1>> {
+    fn default() -> Self {
+        Self {
+            inner: [[0.], [1.]].map(Point::from),
         }
-
-    /// Indicate whether the boundary contains the given element
-    pub fn contains(&self, point: Point<1>) -> bool {
-        let [min, max] = self.normalize().inner;
-        point > min && point < max
-    }
-
-    /// Indicate whether the boundary overlaps another
-    ///
-    /// Boundaries that touch (i.e. their closest boundary elements are equal)
-    /// count as overlapping.
-    pub fn overlaps(&self, other: &Self) -> bool {
-        let [a_low, a_high] = self.normalize().inner;
-        let [b_low, b_high] = other.normalize().inner;
-
-        a_low <= b_high && a_high >= b_low
-    }
-
-    /// Create the difference of this boundary and another
-    ///
-    /// The result will be normalized.
-    pub fn difference(self, other: Self) -> Option<OneOrTwoBoundaries> {
-        let [self_min, self_max] = self.normalize().inner;
-        let [other_min, other_max] = other.normalize().inner;
-
-        match (
-            self_min <= other_min,
-            self_min <= other_max,
-            self_max <= other_min,
-            self_max <= other_max,
-        ) {
-            (true, true, true, true) => {
-                Some(OneOrTwoBoundaries::One(CurveBoundary {
-                    inner: [self_min, self_max],
-                }))
-            }
-            (true, true, false, true) => {
-                let min = self_min;
-                let max = other_min;
-
-                if min == max {
-                    return None;
-                }
-
-                Some(OneOrTwoBoundaries::One(CurveBoundary {
-                    inner: [min, max],
-                }))
-            }
-            (true, true, false, false) => Some(OneOrTwoBoundaries::Two([
-                CurveBoundary {
-                    inner: [self_min, other_min],
-                },
-                CurveBoundary {
-                    inner: [other_max, self_max],
-                },
-            ])),
-            (false, true, false, true) => None,
-            (false, true, false, false) => {
-                Some(OneOrTwoBoundaries::One(CurveBoundary {
-                    inner: [other_max, self_max],
-                }))
-            }
-            (false, false, false, false) => {
-                Some(OneOrTwoBoundaries::One(CurveBoundary {
-                    inner: [self_min, self_max],
-                }))
-            }
-            case => {
-                unreachable!(
-                    "{case:?} is impossible, due to normalization above"
-                );
-            }
-        }
-    }
-
-    /// Create the intersection of this boundary and another
-    ///
-    /// The result will be normalized.
-    #[must_use]
-    pub fn intersection(self, other: Self) -> Self {
-        let self_ = self.normalize();
-        let other = other.normalize();
-
-        let [self_min, self_max] = self_.inner;
-        let [other_min, other_max] = other.inner;
-
-        let min = cmp::max(self_min, other_min);
-        let max = cmp::min(self_max, other_max);
-
-        Self { inner: [min, max] }
-    }
-
-    /// Create the union of this boundary and another
-    ///
-    /// The result will be normalized.
-    ///
-    /// # Panics
-    ///
-    /// Panics, if the two boundaries don't overlap (touching counts as
-    /// overlapping).
-    pub fn union(self, other: Self) -> Self {
-        let self_ = self.normalize();
-        let other = other.normalize();
-
-        assert!(
-            self.overlaps(&other),
-            "Can't merge boundaries that don't at least touch"
-        );
-
-        let [self_min, self_max] = self_.inner;
-        let [other_min, other_max] = other.inner;
-
-        let min = cmp::min(self_min, other_min);
-        let max = cmp::max(self_max, other_max);
-
-        Self { inner: [min, max] }
     }
 }
 
@@ -219,12 +96,6 @@ impl<T: CurveBoundaryElement> PartialOrd for CurveBoundary<T> {
     }
 }
 
-#[derive(Debug, Eq, PartialEq)]
-pub enum OneOrTwoBoundaries {
-    One(CurveBoundary<Point<1>>),
-    Two([CurveBoundary<Point<1>>; 2]),
-}
-
 /// An element of a curve boundary
 ///
 /// Used for the type parameter of [`CurveBoundary`].
@@ -240,125 +111,5 @@ impl CurveBoundaryElement for Point<1> {
 }
 
 impl CurveBoundaryElement for Vertex {
-    type Repr = HandleWrapper<Vertex>;
-}
-
-#[cfg(test)]
-mod tests {
-    use fj_math::Point;
-
-    use crate::geometry::{boundary::OneOrTwoBoundaries, CurveBoundary};
-
-    #[test]
-    fn overlaps() {
-        assert!(overlap([0., 2.], [1., 3.])); // regular overlap
-        assert!(overlap([0., 1.], [1., 2.])); // just touching
-        assert!(overlap([2., 0.], [3., 1.])); // not normalized
-        assert!(overlap([1., 3.], [0., 2.])); // lower boundary comes second
-
-        assert!(!overlap([0., 1.], [2., 3.])); // regular non-overlap
-        assert!(!overlap([2., 3.], [0., 1.])); // lower boundary comes second
-
-        fn overlap(a: [f64; 2], b: [f64; 2]) -> bool {
-            let a = array_to_boundary(a);
-            let b = array_to_boundary(b);
-
-            a.overlaps(&b)
-        }
-    }
-
-    #[test]
-    fn difference() {
-        // `a \ b = x`
-
-        // b covers a exactly
-        diff([1., 2.], [1., 2.], &[]);
-        diff([1., 2.], [2., 1.], &[]);
-        diff([2., 1.], [1., 2.], &[]);
-        diff([2., 1.], [2., 1.], &[]);
-
-        // b covers a, overhang right
-        diff([1., 2.], [1., 3.], &[]);
-        diff([1., 2.], [3., 1.], &[]);
-        diff([2., 1.], [1., 3.], &[]);
-        diff([2., 1.], [3., 1.], &[]);
-
-        // b covers a, overhang left
-        diff([1., 2.], [0., 2.], &[]);
-        diff([1., 2.], [2., 0.], &[]);
-        diff([2., 1.], [0., 2.], &[]);
-        diff([2., 1.], [2., 0.], &[]);
-
-        // b covers a, overhang both sides
-        diff([1., 2.], [0., 3.], &[]);
-        diff([1., 2.], [3., 0.], &[]);
-        diff([2., 1.], [0., 3.], &[]);
-        diff([2., 1.], [3., 0.], &[]);
-
-        // a to the left of b, touching
-        diff([0., 1.], [1., 2.], &[[0., 1.]]);
-        diff([0., 1.], [2., 1.], &[[0., 1.]]);
-        diff([1., 0.], [1., 2.], &[[0., 1.]]);
-        diff([1., 0.], [2., 1.], &[[0., 1.]]);
-
-        // a to the left of b, not touching
-        diff([0., 1.], [2., 3.], &[[0., 1.]]);
-        diff([0., 1.], [3., 2.], &[[0., 1.]]);
-        diff([1., 0.], [2., 3.], &[[0., 1.]]);
-        diff([1., 0.], [3., 2.], &[[0., 1.]]);
-
-        // a to the right of b, touching
-        diff([2., 3.], [1., 2.], &[[2., 3.]]);
-        diff([2., 3.], [2., 1.], &[[2., 3.]]);
-        diff([3., 2.], [1., 2.], &[[2., 3.]]);
-        diff([3., 2.], [2., 1.], &[[2., 3.]]);
-
-        // a to the right of b, not touching
-        diff([2., 3.], [0., 1.], &[[2., 3.]]);
-        diff([2., 3.], [1., 0.], &[[2., 3.]]);
-        diff([3., 2.], [0., 1.], &[[2., 3.]]);
-        diff([3., 2.], [1., 0.], &[[2., 3.]]);
-
-        // b intersects a on the right
-        diff([0., 2.], [1., 3.], &[[0., 1.]]);
-        diff([0., 2.], [3., 1.], &[[0., 1.]]);
-        diff([2., 0.], [1., 3.], &[[0., 1.]]);
-        diff([2., 0.], [3., 1.], &[[0., 1.]]);
-
-        // b intersects a on the left
-        diff([1., 3.], [0., 2.], &[[2., 3.]]);
-        diff([1., 3.], [2., 0.], &[[2., 3.]]);
-        diff([3., 1.], [0., 2.], &[[2., 3.]]);
-        diff([3., 1.], [2., 0.], &[[2., 3.]]);
-
-        // a covers b, overhang both sides
-        diff([0., 3.], [1., 2.], &[[0., 1.], [2., 3.]]);
-        diff([0., 3.], [2., 1.], &[[0., 1.], [2., 3.]]);
-        diff([3., 0.], [1., 2.], &[[0., 1.], [2., 3.]]);
-        diff([3., 0.], [2., 1.], &[[0., 1.], [2., 3.]]);
-
-        fn diff(a: [f64; 2], b: [f64; 2], x: &[[f64; 2]]) {
-            print!("{a:?} \\ {b:?} = ");
-
-            let a = array_to_boundary(a);
-            let b = array_to_boundary(b);
-
-            let x = match x {
-                [] => None,
-                &[x] => Some(OneOrTwoBoundaries::One(array_to_boundary(x))),
-                &[x1, x2] => Some(OneOrTwoBoundaries::Two(
-                    [x1, x2].map(array_to_boundary),
-                )),
-                _ => panic!("Invalid result"),
-            };
-
-            let diff = a.difference(b);
-            println!("{diff:?}");
-            assert_eq!(diff, x);
-        }
-    }
-
-    fn array_to_boundary(array: [f64; 2]) -> CurveBoundary<Point<1>> {
-        CurveBoundary::from(array.map(|element| [element]))
-    }
+    type Repr = Handle<Vertex>;
 }

crates/fj-core/src/geometry/curves/circle.rs

@@ -0,0 +1,173 @@
+//! # Geometry code specific to circles
+
+use fj_interop::{CircleApproxParams, Tolerance};
+use fj_math::{Circle, LineSegment, Point};
+
+use crate::geometry::{CurveBoundary, traits::GenPolyline};
+
+impl<const D: usize> GenPolyline<D> for Circle<D> {
+    fn origin(&self) -> Point<D> {
+        self.center() + self.a()
+    }
+
+    fn line_segment_at(
+        &self,
+        point_curve: Point<1>,
+        tolerance: Tolerance,
+    ) -> LineSegment<D> {
+        let params = CircleApproxParams::new(self.radius(), tolerance);
+
+        // The approximation parameters have an increment, in curve coordinates,
+        // that determines the distance between points on the polyline. Let's
+        // figure out where `point` is on the curve, in units of this increment.
+        let t = point_curve.t / params.increment();
+
+        // Now pick two points on the curve, again in units of approximation
+        // increment, where the locations of the two closest approximation
+        // points to the provided point are.
+        //
+        // Since we are calculating this in increment units, those are integer
+        // numbers.
+        let a = t.floor();
+        let b = t.ceil();
+
+        // Next, convert them into actual curve coordinates.
+        let points_curve = [a, b]
+            .map(|point_curve_in_increment_units| {
+                [point_curve_in_increment_units * params.increment()]
+            })
+            .map(Point::from);
+
+        // And finally, convert those into points of the desired dimensionality.
+        let points = points_curve
+            .map(|point_curve| self.point_from_circle_coords(point_curve));
+
+        LineSegment {
+            points,
+            points_line: points_curve,
+        }
+    }
+
+    fn generate_polyline(
+        &self,
+        boundary: CurveBoundary<Point<1>>,
+        tolerance: Tolerance,
+    ) -> Vec<Point<1>> {
+        let params = CircleApproxParams::new(self.radius(), tolerance);
+        params.approx_circle(boundary.inner).collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::f64::consts::TAU;
+
+    use fj_interop::Tolerance;
+    use fj_math::{Point, Scalar};
+
+    use crate::geometry::{
+        CurveBoundary, curves::circle::Circle, traits::GenPolyline,
+    };
+
+    use super::CircleApproxParams;
+
+    #[test]
+    fn increment_for_circle() {
+        test_increment(1., 0.5, 3.);
+        test_increment(1., 0.1, 7.);
+        test_increment(1., 0.01, 23.);
+
+        fn test_increment(
+            radius: impl Into<Scalar>,
+            tolerance: impl Into<Tolerance>,
+            expected_num_vertices: impl Into<Scalar>,
+        ) {
+            let circle = Circle::from_center_and_radius([0., 0.], radius);
+            let params = CircleApproxParams::new(circle.radius(), tolerance);
+
+            let expected_increment = Scalar::TAU / expected_num_vertices;
+            assert_eq!(params.increment(), expected_increment);
+        }
+    }
+
+    #[test]
+    fn points_for_circle() {
+        // At the chosen values for radius and tolerance (see below), the
+        // increment is `PI / 4`, so ~1.57.
+
+        // Empty range
+        let empty: [Scalar; 0] = [];
+        test_path([[0.], [0.]], empty);
+
+        // Ranges contain all generated points. Start is before the first
+        // increment and after the last one in each case.
+        test_path([[0.], [TAU]], [1., 2., 3.]);
+        test_path([[1.], [TAU]], [1., 2., 3.]);
+        test_path([[0.], [TAU - 1.]], [1., 2., 3.]);
+
+        // Here the range is restricted to cut of the first or last increment.
+        test_path([[2.], [TAU]], [2., 3.]);
+        test_path([[0.], [TAU - 2.]], [1., 2.]);
+
+        // And everything again, but in reverse.
+        test_path([[TAU], [0.]], [3., 2., 1.]);
+        test_path([[TAU], [1.]], [3., 2., 1.]);
+        test_path([[TAU - 1.], [0.]], [3., 2., 1.]);
+        test_path([[TAU], [2.]], [3., 2.]);
+        test_path([[TAU - 2.], [0.]], [2., 1.]);
+
+        fn test_path(
+            boundary: impl Into<CurveBoundary<Point<1>>>,
+            expected_coords: impl IntoIterator<Item = impl Into<Scalar>>,
+        ) {
+            // Choose radius and tolerance such, that we need 4 vertices to
+            // approximate a full circle. This is the lowest number that we can
+            // still cover all the edge cases with
+            let radius = 1.;
+            let tolerance = 0.375;
+
+            let circle = Circle::from_center_and_radius([0., 0.], radius);
+            let params = CircleApproxParams::new(circle.radius(), tolerance);
+
+            let points = params
+                .approx_circle(boundary.into().inner)
+                .collect::<Vec<_>>();
+
+            let expected_points = expected_coords
+                .into_iter()
+                .map(|i| Point::from([params.increment() * i]))
+                .collect::<Vec<_>>();
+            assert_eq!(points, expected_points);
+        }
+    }
+
+    #[test]
+    fn curve_representation_must_be_deterministic() -> anyhow::Result<()> {
+        let circle = Circle::from_center_and_radius([0., 0.], 1.);
+
+        // Deliberately choose a very coarse tolerance, so the circle
+        // representation degenerates to a predictable triangle.
+        let tolerance = Tolerance::from_scalar(1.)?;
+
+        // Sample the circle at two points that are close together, relative to
+        // our tolerance. The intent here is to each time sample the same
+        // triangle edge, so also make sure they're not around zero, or another
+        // point where two edges are likely to meet.
+        //
+        // Where those edges meet is implementation-dependent of course, so this
+        // test might break if that implementation changes. But I don't think
+        // that really matters. We just need to make sure that this test doesn't
+        // accidentally hit such a point. Where specifically those points are,
+        // doesn't matter.
+        let a = circle.line_segment_at(Point::from([0.2]), tolerance);
+        let b = circle.line_segment_at(Point::from([0.3]), tolerance);
+
+        assert_eq!(
+            a, b,
+            "Expecting representation of the curve to be deterministic; it \
+            must not depend on the specific points that were sampled.",
+        );
+
+        Ok(())
+    }
+}

crates/fj-core/src/geometry/curves/line.rs

@@ -0,0 +1,34 @@
+//! # Geometry code specific to lines
+
+use fj_interop::Tolerance;
+use fj_math::{Line, LineSegment, Point};
+
+use crate::geometry::{CurveBoundary, traits::GenPolyline};
+
+impl<const D: usize> GenPolyline<D> for Line<D> {
+    fn origin(&self) -> Point<D> {
+        self.origin()
+    }
+
+    fn line_segment_at(
+        &self,
+        point_curve: Point<1>,
+        _: Tolerance,
+    ) -> LineSegment<D> {
+        // Collapse line segment into a point, as per documentation.
+        let point = self.origin() + self.direction() * point_curve.t;
+
+        LineSegment {
+            points: [point; 2],
+            points_line: [point_curve; 2],
+        }
+    }
+
+    fn generate_polyline(
+        &self,
+        boundary: CurveBoundary<Point<1>>,
+        _: Tolerance,
+    ) -> Vec<Point<1>> {
+        boundary.inner.into()
+    }
+}

crates/fj-core/src/geometry/curves/mod.rs

@@ -0,0 +1,4 @@
+//! # Geometry code specific to various types of curves
+
+pub mod circle;
+pub mod line;

crates/fj-core/src/geometry/geometry.rs

@@ -3,16 +3,28 @@ use std::collections::BTreeMap;
 use fj_math::Vector;
 
 use crate::{
-    objects::{HalfEdge, Objects, Surface},
-    storage::{Handle, HandleWrapper},
+    storage::Handle,
+    topology::{Curve, Surface, Topology, Vertex},
 };
 
-use super::{GlobalPath, HalfEdgeGeometry, SurfaceGeometry};
+use super::{
+    Path, VertexGeom,
+    repr::{polyline::Polyline, tri_mesh::TriMesh},
+    surfaces::SweptCurve,
+    traits::{GenPolyline, GenTriMesh},
+    vertex::LocalVertexGeom,
+};
 
 /// Geometric data that is associated with topological objects
 pub struct Geometry {
-    half_edge: BTreeMap<Handle<HalfEdge>, HalfEdgeGeometry>,
-    surface: BTreeMap<HandleWrapper<Surface>, SurfaceGeometry>,
+    curve: BTreeMap<Handle<Curve>, CurveGeom>,
+    surface: BTreeMap<Handle<Surface>, SweptCurve>,
+    vertex: BTreeMap<Handle<Vertex>, VertexGeom>,
+
+    curves: BTreeMap<Handle<Curve>, CurveGeom2>,
+    surfaces: BTreeMap<Handle<Surface>, SurfaceGeom>,
+
+    space_2d: Handle<Surface>,
 
     xy_plane: Handle<Surface>,
     xz_plane: Handle<Surface>,
@@ -21,96 +33,298 @@ pub struct Geometry {
 
 impl Geometry {
     /// Create a new instance of `Geometry`
-    pub fn new(objects: &Objects) -> Self {
+    pub fn new(topology: &Topology) -> Self {
         let mut self_ = Self {
-            half_edge: BTreeMap::new(),
+            curve: BTreeMap::new(),
             surface: BTreeMap::new(),
+            vertex: BTreeMap::new(),
 
-            xy_plane: objects.surfaces.xy_plane(),
-            xz_plane: objects.surfaces.xz_plane(),
-            yz_plane: objects.surfaces.yz_plane(),
+            curves: BTreeMap::new(),
+            surfaces: BTreeMap::new(),
+
+            space_2d: topology.surfaces.space_2d(),
+
+            xy_plane: topology.surfaces.xy_plane(),
+            xz_plane: topology.surfaces.xz_plane(),
+            yz_plane: topology.surfaces.yz_plane(),
         };
 
         self_.define_surface_inner(
             self_.xy_plane.clone(),
-            SurfaceGeometry {
-                u: GlobalPath::x_axis(),
+            SweptCurve {
+                u: Path::x_axis(),
                 v: Vector::unit_y(),
             },
         );
         self_.define_surface_inner(
             self_.xz_plane.clone(),
-            SurfaceGeometry {
-                u: GlobalPath::x_axis(),
+            SweptCurve {
+                u: Path::x_axis(),
                 v: Vector::unit_z(),
             },
         );
         self_.define_surface_inner(
             self_.yz_plane.clone(),
-            SurfaceGeometry {
-                u: GlobalPath::y_axis(),
+            SweptCurve {
+                u: Path::y_axis(),
                 v: Vector::unit_z(),
             },
         );
 
+        self_.define_surface_inner_2(
+            self_.xy_plane.clone(),
+            SurfaceGeom {
+                generator: Box::new(SweptCurve {
+                    u: Path::x_axis(),
+                    v: Vector::unit_y(),
+                }),
+                geometry: TriMesh::empty(),
+            },
+        );
+        self_.define_surface_inner_2(
+            self_.xz_plane.clone(),
+            SurfaceGeom {
+                generator: Box::new(SweptCurve {
+                    u: Path::x_axis(),
+                    v: Vector::unit_z(),
+                }),
+                geometry: TriMesh::empty(),
+            },
+        );
+        self_.define_surface_inner_2(
+            self_.yz_plane.clone(),
+            SurfaceGeom {
+                generator: Box::new(SweptCurve {
+                    u: Path::y_axis(),
+                    v: Vector::unit_z(),
+                }),
+                geometry: TriMesh::empty(),
+            },
+        );
+
         self_
     }
 
-    pub(crate) fn define_half_edge_inner(
+    pub(crate) fn define_curve_inner(
         &mut self,
-        half_edge: Handle<HalfEdge>,
-        geometry: HalfEdgeGeometry,
+        curve: Handle<Curve>,
+        surface: Handle<Surface>,
+        geometry: LocalCurveGeom,
     ) {
-        self.half_edge.insert(half_edge, geometry);
+        self.curve
+            .entry(curve)
+            .or_default()
+            .definitions
+            .insert(surface, geometry);
+    }
+
+    pub(crate) fn define_curve_inner_2(
+        &mut self,
+        curve: Handle<Curve>,
+        geometry: CurveGeom2,
+    ) {
+        self.curves.insert(curve, geometry);
     }
 
     pub(crate) fn define_surface_inner(
         &mut self,
         surface: Handle<Surface>,
-        geometry: SurfaceGeometry,
+        geometry: SweptCurve,
     ) {
-        self.surface.insert(surface.into(), geometry);
+        if surface == self.space_2d {
+            panic!("Attempting to define geometry for 2D space");
         }
 
-    /// # Access the geometry of the provided half-edge
-    ///
-    /// ## Panics
-    ///
-    /// Panics, if the geometry of the half-edge is not defined.
-    pub fn of_half_edge(
-        &self,
-        half_edge: &Handle<HalfEdge>,
-    ) -> HalfEdgeGeometry {
-        self.half_edge
-            .get(half_edge)
-            .copied()
-            .expect("Expected geometry of half-edge to be defined")
+        if self.surface.contains_key(&surface)
+            && (surface == self.xy_plane
+                || surface == self.xz_plane
+                || surface == self.yz_plane)
+        {
+            panic!("Attempting to redefine basis plane.");
+        }
+
+        self.surface.insert(surface, geometry);
+    }
+
+    pub(crate) fn define_surface_inner_2(
+        &mut self,
+        surface: Handle<Surface>,
+        geometry: SurfaceGeom,
+    ) {
+        if surface == self.space_2d {
+            panic!("Attempting to define geometry for 2D space");
+        }
+
+        if self.surfaces.contains_key(&surface)
+            && (surface == self.xy_plane
+                || surface == self.xz_plane
+                || surface == self.yz_plane)
+        {
+            panic!("Attempting to redefine basis plane.");
+        }
+
+        self.surfaces.insert(surface, geometry);
+    }
+
+    pub(crate) fn define_vertex_inner(
+        &mut self,
+        vertex: Handle<Vertex>,
+        curve: Handle<Curve>,
+        geometry: LocalVertexGeom,
+    ) {
+        self.vertex
+            .entry(vertex)
+            .or_default()
+            .definitions
+            .insert(curve, geometry);
+    }
+
+    /// # Access the geometry of the provided curve
+    pub fn of_curve(&self, curve: &Handle<Curve>) -> Option<&CurveGeom> {
+        self.curve.get(curve)
     }
 
     /// # Access the geometry of the provided surface
     ///
     /// ## Panics
     ///
-    /// Panics, if the geometry of surface is not defined.
-    pub fn of_surface(&self, surface: &Handle<Surface>) -> SurfaceGeometry {
+    /// Panics, if the geometry of the surface is not defined.
+    pub fn of_surface(&self, surface: &Handle<Surface>) -> &SweptCurve {
         self.surface
-            .get(&surface.clone().into())
-            .copied()
+            .get(surface)
             .expect("Expected geometry of surface to be defined")
     }
 
+    /// # Access the geometry of the provided vertex
+    pub fn of_vertex(&self, vertex: &Handle<Vertex>) -> Option<&VertexGeom> {
+        self.vertex.get(vertex)
+    }
+
+    /// # Access the geometry of the provided curve
+    ///
+    /// ## Implementation Note
+    ///
+    /// There currently is an ongoing transition to a new geometry system. This
+    /// method returns new-style geometry. Its name is temporary, while the
+    /// method returning the old-style geometry is still taking up the more
+    /// concise name.
+    pub fn of_curve_2(&self, curve: &Handle<Curve>) -> Option<&CurveGeom2> {
+        self.curves.get(curve)
+    }
+
+    /// # Access the geometry of the provided surface
+    ///
+    /// ## Implementation Note
+    ///
+    /// There currently is an ongoing transition to a new geometry system. This
+    /// method returns new-style geometry. Its name is temporary, while the
+    /// method returning the old-style geometry is still taking up the more
+    /// concise name.
+    pub fn of_surface_2(
+        &self,
+        surface: &Handle<Surface>,
+    ) -> Option<&SurfaceGeom> {
+        self.surfaces.get(surface)
+    }
+
     /// Access the geometry of the xy-plane
-    pub fn xy_plane(&self) -> SurfaceGeometry {
+    pub fn xy_plane(&self) -> &SweptCurve {
         self.of_surface(&self.xy_plane)
     }
 
     /// Access the geometry of the xz-plane
-    pub fn xz_plane(&self) -> SurfaceGeometry {
+    pub fn xz_plane(&self) -> &SweptCurve {
         self.of_surface(&self.xz_plane)
     }
 
     /// Access the geometry of the yz-plane
-    pub fn yz_plane(&self) -> SurfaceGeometry {
+    pub fn yz_plane(&self) -> &SweptCurve {
         self.of_surface(&self.yz_plane)
     }
 }
+
+/// The geometric definition of a curve
+#[derive(Clone, Debug, Default)]
+pub struct CurveGeom {
+    /// # The redundant local definitions of the curve geometry
+    ///
+    /// ## Implementation Note
+    ///
+    /// Having multiple redundant definitions is undesirable. However, we can't
+    /// just use one global definition in 3D, as we need the local 2D
+    /// definitions to triangulate faces, and we currently don't have the tools
+    /// to project a global definition into a local context.
+    ///
+    /// Eventually, it should be possible to define the geometry of a curve
+    /// once, either locally or globally, and then convert that single
+    /// definition into (other) local contexts, as needed. There currently is no
+    /// issue to track that specifically, but there is the following issue,
+    /// which is a prerequisite for making the required tooling practical:
+    ///
+    /// <https://github.com/hannobraun/fornjot/issues/2118>
+    pub definitions: BTreeMap<Handle<Surface>, LocalCurveGeom>,
+}
+
+impl CurveGeom {
+    /// # Return the local definition on the provided surface
+    pub fn local_on(
+        &self,
+        surface: &Handle<Surface>,
+    ) -> Option<&LocalCurveGeom> {
+        self.definitions.get(surface)
+    }
+}
+
+/// The geometric definition of a curve, in 2D surface coordinates
+#[derive(Clone, Debug)]
+pub struct LocalCurveGeom {
+    /// The path that defines the curve on its surface
+    pub path: Path<2>,
+}
+
+/// # The representation of a curve's geometry
+///
+/// Curves are represented by polylines, their uniform intermediate
+/// representation. However, this representation can be 2D (local to a surface)
+/// or 3D. This enum distinguishes between the two cases.
+///
+/// ## Implementation Note
+///
+/// There currently is an ongoing transition to a new geometry system. This type
+/// represents new-style geometry. Its name is temporary, while the type
+/// representing the old-style geometry is still taking up the more concise
+/// name.
+pub enum CurveGeom2 {
+    /// # The curve is defined locally on a surface
+    Surface {
+        /// # A generator for local curve geometry
+        generator: Box<dyn GenPolyline<2>>,
+
+        /// # The local representation of curve geometry
+        geometry: Polyline<2>,
+
+        /// # The surface that the curve geometry is defined on
+        surface: Handle<Surface>,
+    },
+
+    /// # The curve is defined globally in 3D space
+    Global {
+        /// # A generator for global curve geometry
+        generator: Box<dyn GenPolyline<3>>,
+
+        /// # The global representation of curve geometry
+        geometry: Polyline<3>,
+    },
+}
+
+/// # The representation of a surface's geometry
+///
+/// Surface are represented by triangle meshes, their uniform intermediate
+/// representation.
+pub struct SurfaceGeom {
+    /// # A generator for surface geometry
+    pub generator: Box<dyn GenTriMesh>,
+
+    /// # The generated surface geometry
+    pub geometry: TriMesh,
+}

crates/fj-core/src/geometry/half_edge.rs

@@ -1,32 +0,0 @@
-use super::SurfacePath;
-
-/// The geometry of a half-edge
-#[derive(Copy, Clone)]
-pub struct HalfEdgeGeometry {
-    /// # The path of the half-edge
-    ///
-    /// ## Implementation Note
-    ///
-    /// Currently, all curve-related geometry is defined locally, in terms of
-    /// the surface that the curve is on (or purely in 2D, if there is no
-    /// surface associated with this geometry). However, curves exist globally,
-    /// independently of surfaces. Half-edges in multiple surfaces can refer to
-    /// the same curve, and in fact, that is the whole reason for their
-    /// existence as a topological object.
-    ///
-    /// This contradiction, globally defined curves but locally defined curve
-    /// geometry, is the reason that this curve geometry is defined right here,
-    /// associated with a locally existing half-edge. (And, I might add,
-    /// redundantly so, as multiple half-edges within the same surface context
-    /// can refer to the same curve.)
-    ///
-    /// Instead, it should be possible to define curve geometry *either* locally
-    /// or globally. Then that respective definition can be associated with the
-    /// curve (and possibly, in addition, a surface). How exactly that is going
-    /// to work is up in the air.
-    ///
-    /// The point of all this exposition is to clarify that this field doesn't
-    /// really belong here. It exists here for practical reasons that are,
-    /// hopefully, temporary.
-    pub path: SurfacePath,
-}

crates/fj-core/src/geometry/mod.rs

@@ -1,15 +1,18 @@
-//! Types that are tied to objects, but aren't objects themselves
+//! Geometry that is applied to the topological object graph
+
+pub mod curves;
+pub mod repr;
+pub mod surfaces;
+pub mod traits;
 
 mod boundary;
 mod geometry;
-mod half_edge;
 mod path;
-mod surface;
+mod vertex;
 
 pub use self::{
     boundary::{CurveBoundary, CurveBoundaryElement},
-    geometry::Geometry,
-    half_edge::HalfEdgeGeometry,
-    path::{GlobalPath, SurfacePath},
-    surface::SurfaceGeometry,
+    geometry::{CurveGeom, CurveGeom2, Geometry, LocalCurveGeom, SurfaceGeom},
+    path::Path,
+    vertex::{LocalVertexGeom, VertexGeom},
 };

crates/fj-core/src/geometry/path.rs

@@ -1,28 +1,20 @@
 //! Paths through 2D and 3D space
 //!
-//! See [`SurfacePath`] and [`GlobalPath`].
+//! See [`Path`].
 
 use fj_math::{Circle, Line, Point, Scalar, Transform, Vector};
 
-/// A path through surface (2D) space
+/// A path through surface (2D) or global (3D) space
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub enum SurfacePath {
+pub enum Path<const D: usize> {
     /// A circle
-    Circle(Circle<2>),
+    Circle(Circle<D>),
 
     /// A line
-    Line(Line<2>),
+    Line(Line<D>),
 }
 
-impl SurfacePath {
-    /// Build a circle from the given radius
-    pub fn circle_from_center_and_radius(
-        center: impl Into<Point<2>>,
-        radius: impl Into<Scalar>,
-    ) -> Self {
-        Self::Circle(Circle::from_center_and_radius(center, radius))
-    }
-
+impl Path<2> {
     /// Build a line that represents the u-axis of the surface its on
     pub fn u_axis() -> Self {
         let a = Point::origin();
@@ -40,57 +32,10 @@ impl SurfacePath {
         let (self_, _) = Self::line_from_points([a, b]);
         self_
     }
-
-    /// Construct a line from two points
-    ///
-    /// Also returns the coordinates of the points on the path.
-    pub fn line_from_points(
-        points: [impl Into<Point<2>>; 2],
-    ) -> (Self, [Point<1>; 2]) {
-        let (line, coords) = Line::from_points(points);
-        (Self::Line(line), coords)
-    }
-
-    /// Create a line from two points that include line coordinates
-    pub fn line_from_points_with_coords(
-        points: [(impl Into<Point<1>>, impl Into<Point<2>>); 2],
-    ) -> Self {
-        Self::Line(Line::from_points_with_line_coords(points))
-    }
-
-    /// Convert a point on the path into surface coordinates
-    pub fn point_from_path_coords(
-        &self,
-        point: impl Into<Point<1>>,
-    ) -> Point<2> {
-        match self {
-            Self::Circle(circle) => circle.point_from_circle_coords(point),
-            Self::Line(line) => line.point_from_line_coords(point),
-        }
-    }
-
-    /// Create a new path that is the reverse of this one
-    #[must_use]
-    pub fn reverse(self) -> Self {
-        match self {
-            Self::Circle(circle) => Self::Circle(circle.reverse()),
-            Self::Line(line) => Self::Line(line.reverse()),
-        }
-    }
 }
 
-/// A path through global (3D) space
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub enum GlobalPath {
-    /// A circle
-    Circle(Circle<3>),
-
-    /// A line
-    Line(Line<3>),
-}
-
-impl GlobalPath {
-    /// Construct a `GlobalPath` that represents the x-axis
+impl Path<3> {
+    /// Construct a `Path` that represents the x-axis
     pub fn x_axis() -> Self {
         Self::Line(Line::from_origin_and_direction(
             Point::origin(),
@@ -98,7 +43,7 @@ impl GlobalPath {
         ))
     }
 
-    /// Construct a `GlobalPath` that represents the y-axis
+    /// Construct a `Path` that represents the y-axis
     pub fn y_axis() -> Self {
         Self::Line(Line::from_origin_and_direction(
             Point::origin(),
@@ -106,7 +51,7 @@ impl GlobalPath {
         ))
     }
 
-    /// Construct a `GlobalPath` that represents the z-axis
+    /// Construct a `Path` that represents the z-axis
     pub fn z_axis() -> Self {
         Self::Line(Line::from_origin_and_direction(
             Point::origin(),
@@ -114,6 +59,25 @@ impl GlobalPath {
         ))
     }
 
+    /// Transform the path
+    #[must_use]
+    pub fn transform(self, transform: &Transform) -> Self {
+        match self {
+            Self::Circle(curve) => Self::Circle(curve.transform(transform)),
+            Self::Line(curve) => Self::Line(curve.transform(transform)),
+        }
+    }
+}
+
+impl<const D: usize> Path<D> {
+    /// Build a circle from the given radius
+    pub fn circle_from_center_and_radius(
+        center: impl Into<Point<D>>,
+        radius: impl Into<Scalar>,
+    ) -> Self {
+        Self::Circle(Circle::from_center_and_radius(center, radius))
+    }
+
     /// Build a circle from the given radius
     pub fn circle_from_radius(radius: impl Into<Scalar>) -> Self {
         let radius = radius.into();
@@ -125,25 +89,24 @@ impl GlobalPath {
     ///
     /// Also returns the coordinates of the points on the path.
     pub fn line_from_points(
-        points: [impl Into<Point<3>>; 2],
+        points: [impl Into<Point<D>>; 2],
     ) -> (Self, [Point<1>; 2]) {
         let (line, coords) = Line::from_points(points);
         (Self::Line(line), coords)
     }
 
-    /// Access the origin of the path's coordinate system
-    pub fn origin(&self) -> Point<3> {
-        match self {
-            Self::Circle(circle) => circle.center() + circle.a(),
-            Self::Line(line) => line.origin(),
-        }
+    /// Create a line from two points that include line coordinates
+    pub fn line_from_points_with_coords(
+        points: [(impl Into<Point<1>>, impl Into<Point<D>>); 2],
+    ) -> Self {
+        Self::Line(Line::from_points_with_line_coords(points))
     }
 
-    /// Convert a point on the path into global coordinates
+    /// Convert a point on the path into surface coordinates
     pub fn point_from_path_coords(
         &self,
         point: impl Into<Point<1>>,
-    ) -> Point<3> {
+    ) -> Point<D> {
         match self {
             Self::Circle(circle) => circle.point_from_circle_coords(point),
             Self::Line(line) => line.point_from_line_coords(point),
@@ -154,21 +117,19 @@ impl GlobalPath {
     pub fn vector_from_path_coords(
         &self,
         vector: impl Into<Vector<1>>,
-    ) -> Vector<3> {
+    ) -> Vector<D> {
         match self {
             Self::Circle(circle) => circle.vector_from_circle_coords(vector),
             Self::Line(line) => line.vector_from_line_coords(vector),
         }
     }
 
-    /// Transform the path
+    /// Create a new path that is the reverse of this one
     #[must_use]
-    pub fn transform(self, transform: &Transform) -> Self {
+    pub fn reverse(self) -> Self {
         match self {
-            Self::Circle(curve) => {
-                Self::Circle(transform.transform_circle(&curve))
-            }
-            Self::Line(curve) => Self::Line(transform.transform_line(&curve)),
+            Self::Circle(circle) => Self::Circle(circle.reverse()),
+            Self::Line(line) => Self::Line(line.reverse()),
         }
     }
 }

crates/fj-core/src/geometry/repr/mod.rs

@@ -0,0 +1,4 @@
+//! # The uniform intermediate representations of geometry
+
+pub mod polyline;
+pub mod tri_mesh;

crates/fj-core/src/geometry/repr/polyline.rs

@@ -0,0 +1,94 @@
+//! # Geometric utility code based on polylines
+
+use std::iter;
+
+use fj_interop::Tolerance;
+use fj_math::{Aabb, LineSegment, Point};
+
+use crate::geometry::{CurveBoundary, traits::GenPolyline};
+
+/// # A polyline, the uniform representation of curve geometry
+///
+/// Can be 2- or 3-dimensional, as specified by the `D` type parameter.
+pub struct Polyline<const D: usize> {
+    /// # The connecting points between line segments
+    pub points: Vec<Point<D>>,
+
+    /// # The connecting points between line segments, in curve coordinates
+    pub points_curve: Vec<Point<1>>,
+}
+
+impl<const D: usize> Polyline<D> {
+    /// # Create an instance of `Polyline` from a curve
+    pub fn from_curve(
+        curve: &dyn GenPolyline<D>,
+        boundary: impl Into<CurveBoundary<Point<1>>>,
+        tolerance: impl Into<Tolerance>,
+    ) -> Self {
+        let boundary = boundary.into();
+        let tolerance = tolerance.into();
+
+        let points_curve = curve.generate_polyline(boundary, tolerance);
+        let points = points_curve
+            .iter()
+            .map(|&point_curve| {
+                convert_from_curve_point(curve, point_curve, tolerance)
+            })
+            .collect();
+
+        Self {
+            points,
+            points_curve,
+        }
+    }
+
+    /// # Iterate over the line segments of this polyline
+    pub fn line_segments(&self) -> impl Iterator<Item = LineSegment<D>> + '_ {
+        let mut i = 0;
+
+        iter::from_fn(move || {
+            let points = [*self.points.get(i)?, *self.points.get(i + 1)?];
+            let points_line =
+                [*self.points_curve.get(i)?, *self.points_curve.get(i + 1)?];
+
+            i += 1;
+
+            Some(LineSegment {
+                points,
+                points_line,
+            })
+        })
+    }
+}
+
+/// # Convert a point on a curve from curve coordinates to surface coordinates
+pub fn convert_from_curve_point<const D: usize>(
+    curve: &dyn GenPolyline<D>,
+    point_curve: impl Into<Point<1>>,
+    tolerance: impl Into<Tolerance>,
+) -> Point<D> {
+    let point_curve = point_curve.into();
+    let tolerance = tolerance.into();
+
+    let line_segment = curve.line_segment_at(point_curve, tolerance);
+    let line = line_segment.to_line();
+
+    line.point_from_line_coords(point_curve)
+}
+
+/// # Generate a 2D axis-aligned bounding box for a curve in a given range
+pub fn surface_aabb_from_bounded_curve(
+    curve: &dyn GenPolyline<2>,
+    boundary: impl Into<CurveBoundary<Point<1>>>,
+    tolerance: impl Into<Tolerance>,
+) -> Aabb<2> {
+    let boundary = boundary.into();
+    let tolerance = tolerance.into();
+
+    let points_curve = curve.generate_polyline(boundary, tolerance);
+    let points_surface = points_curve.into_iter().map(|point_curve| {
+        convert_from_curve_point(curve, point_curve, tolerance)
+    });
+
+    Aabb::<2>::from_points(points_surface)
+}

crates/fj-core/src/geometry/repr/tri_mesh.rs

@@ -0,0 +1,50 @@
+//! # Geometric utility code based on triangle meshes
+
+use fj_interop::Tolerance;
+use fj_math::{Point, Vector};
+
+use crate::geometry::{Geometry, traits::GenTriMesh};
+
+/// # A triangle mesh, the uniform intermediate representation of a surface
+///
+/// ## Implementation
+///
+/// This struct is currently a placeholder, while the transition to the new
+/// geometry system is ongoing.
+pub struct TriMesh {}
+
+impl TriMesh {
+    /// # Construct an empty triangle mesh
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// # Convert a point in surface coordinates to global coordinates
+pub fn convert_point_surface_to_global(
+    surface: &dyn GenTriMesh,
+    point: impl Into<Point<2>>,
+    tolerance: impl Into<Tolerance>,
+    geometry: &Geometry,
+) -> Point<3> {
+    let (triangle, barycentric_coords) =
+        surface.triangle_at(point.into(), tolerance.into(), geometry);
+    triangle.point_from_barycentric_coords(barycentric_coords)
+}
+
+/// # Convert a vector in surface coordinates to global coordinates
+pub fn convert_vector_surface_to_global(
+    surface: &dyn GenTriMesh,
+    vector: impl Into<Vector<2>>,
+    tolerance: impl Into<Tolerance>,
+    geometry: &Geometry,
+) -> Vector<3> {
+    let vector = vector.into();
+    let point = convert_point_surface_to_global(
+        surface,
+        Point { coords: vector },
+        tolerance,
+        geometry,
+    );
+    point - surface.origin(geometry)
+}

crates/fj-core/src/geometry/surface.rs

@@ -1,100 +0,0 @@
-//! The geometry that defines a surface
-
-use fj_math::{Line, Plane, Point, Transform, Vector};
-
-use super::GlobalPath;
-
-/// The geometry that defines a surface
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct SurfaceGeometry {
-    /// The u-axis of the surface
-    pub u: GlobalPath,
-
-    /// The v-axis of the surface
-    pub v: Vector<3>,
-}
-
-impl SurfaceGeometry {
-    /// Convert a point in surface coordinates to model coordinates
-    pub fn point_from_surface_coords(
-        &self,
-        point: impl Into<Point<2>>,
-    ) -> Point<3> {
-        let point = point.into();
-        self.u.point_from_path_coords([point.u])
-            + self.path_to_line().vector_from_line_coords([point.v])
-    }
-
-    /// Convert a vector in surface coordinates to model coordinates
-    pub fn vector_from_surface_coords(
-        &self,
-        vector: impl Into<Vector<2>>,
-    ) -> Vector<3> {
-        let vector = vector.into();
-        self.u.vector_from_path_coords([vector.u])
-            + self.path_to_line().vector_from_line_coords([vector.v])
-    }
-
-    fn path_to_line(&self) -> Line<3> {
-        Line::from_origin_and_direction(self.u.origin(), self.v)
-    }
-
-    /// Project the global point into the surface
-    pub fn project_global_point(&self, point: impl Into<Point<3>>) -> Point<2> {
-        let GlobalPath::Line(line) = self.u else {
-            todo!("Projecting point into non-plane surface is not supported")
-        };
-
-        let plane =
-            Plane::from_parametric(line.origin(), line.direction(), self.v);
-        plane.project_point(point)
-    }
-
-    /// Transform the surface geometry
-    #[must_use]
-    pub fn transform(self, transform: &Transform) -> Self {
-        let u = self.u.transform(transform);
-        let v = transform.transform_vector(&self.v);
-        Self { u, v }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use fj_math::{Line, Point, Vector};
-    use pretty_assertions::assert_eq;
-
-    use crate::geometry::{GlobalPath, SurfaceGeometry};
-
-    #[test]
-    fn point_from_surface_coords() {
-        let surface = SurfaceGeometry {
-            u: GlobalPath::Line(Line::from_origin_and_direction(
-                Point::from([1., 1., 1.]),
-                Vector::from([0., 2., 0.]),
-            )),
-            v: Vector::from([0., 0., 2.]),
-        };
-
-        assert_eq!(
-            surface.point_from_surface_coords([2., 4.]),
-            Point::from([1., 5., 9.]),
-        );
-    }
-
-    #[test]
-    fn vector_from_surface_coords() {
-        let surface = SurfaceGeometry {
-            u: GlobalPath::Line(Line::from_origin_and_direction(
-                Point::from([1., 0., 0.]),
-                Vector::from([0., 2., 0.]),
-            )),
-            v: Vector::from([0., 0., 2.]),
-        };
-
-        assert_eq!(
-            surface.vector_from_surface_coords([2., 4.]),
-            Vector::from([0., 4., 8.]),
-        );
-    }
-}

crates/fj-core/src/geometry/surfaces/mod.rs

@@ -0,0 +1,8 @@
+//! # Geometry code specific to various types of surfaces
+
+mod swept_curve;
+mod transformed_surface;
+
+pub use self::{
+    swept_curve::SweptCurve, transformed_surface::TransformedSurface,
+};

crates/fj-core/src/geometry/surfaces/swept_curve.rs

@@ -0,0 +1,66 @@
+use fj_interop::Tolerance;
+use fj_math::{Aabb, Point, Scalar, Triangle, Vector};
+
+use crate::geometry::{
+    Geometry, Path,
+    traits::{GenPolyline, GenTriMesh},
+};
+
+/// # A surface that is a curve, swept along a path
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct SweptCurve {
+    /// The u-axis of the surface
+    pub u: Path<3>,
+
+    /// The v-axis of the surface
+    pub v: Vector<3>,
+}
+
+impl GenTriMesh for SweptCurve {
+    fn origin(&self, _: &Geometry) -> Point<3> {
+        self.u.origin()
+    }
+
+    fn triangle_at(
+        &self,
+        point_surface: Point<2>,
+        tolerance: Tolerance,
+        _: &Geometry,
+    ) -> (Triangle<3>, [Scalar; 3]) {
+        let [a, b] = self
+            .u
+            .line_segment_at(Point::from([point_surface.u]), tolerance)
+            .points
+            .map(|point_global| point_global + self.v * point_surface.v);
+
+        let c = a + (b - a) / 2.;
+        let triangle = Triangle::from([a, b, c]);
+
+        let barycentric_coords = [1. / 3.; 3].map(Into::into);
+        (triangle, barycentric_coords)
+    }
+
+    fn generate_tri_mesh(
+        &self,
+        boundary: Aabb<2>,
+        tolerance: Tolerance,
+        _: &Geometry,
+    ) -> Vec<Point<2>> {
+        let boundary_curve = [[boundary.min.u], [boundary.max.u]];
+        let points_curve =
+            self.u.generate_polyline(boundary_curve.into(), tolerance);
+
+        points_curve
+            .iter()
+            .copied()
+            .map(|point| [point.t, Scalar::ZERO])
+            .chain(
+                points_curve
+                    .iter()
+                    .copied()
+                    .map(|point| [point.t, self.v.magnitude()]),
+            )
+            .map(Point::from)
+            .collect()
+    }
+}

crates/fj-core/src/geometry/surfaces/transformed_surface.rs

@@ -0,0 +1,56 @@
+use fj_interop::Tolerance;
+use fj_math::{Aabb, Point, Scalar, Transform, Triangle};
+
+use crate::{
+    geometry::{Geometry, traits::GenTriMesh},
+    storage::Handle,
+    topology::Surface,
+};
+
+/// # A surface that is a transformation of another surface
+pub struct TransformedSurface {
+    /// # The original surface that is being transformed
+    pub surface: Handle<Surface>,
+
+    /// # The transform that is applied to the original surface
+    pub transform: Transform,
+}
+
+impl GenTriMesh for TransformedSurface {
+    fn origin(&self, geometry: &Geometry) -> Point<3> {
+        let surface = geometry.of_surface_2(&self.surface).unwrap();
+        self.transform
+            .transform_point(&surface.generator.origin(geometry))
+    }
+
+    fn triangle_at(
+        &self,
+        point_surface: Point<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> (Triangle<3>, [Scalar; 3]) {
+        let surface = geometry.of_surface_2(&self.surface).unwrap();
+        let (triangle, barycentric_coords) =
+            surface
+                .generator
+                .triangle_at(point_surface, tolerance, geometry);
+
+        let triangle = self.transform.transform_triangle(&triangle);
+
+        (triangle, barycentric_coords)
+    }
+
+    fn generate_tri_mesh(
+        &self,
+        boundary: Aabb<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> Vec<Point<2>> {
+        // The triangle mesh is generated in 2D surface coordinates. No need to
+        // transform that.
+        let surface = geometry.of_surface_2(&self.surface).unwrap();
+        surface
+            .generator
+            .generate_tri_mesh(boundary, tolerance, geometry)
+    }
+}

crates/fj-core/src/geometry/traits.rs

@@ -0,0 +1,183 @@
+//! # Traits that abstract over curve or surface geometry
+//!
+//! Fornjot's geometry is built on the concept of a uniform representation:
+//! Polylines to represent curves and triangle meshes to represent surfaces. The
+//! traits in this module provide the interface between this uniform
+//! representation and specific geometry code.
+//!
+//! ## Determinism
+//!
+//! Uniform representation must be deterministic. That means a given geometric
+//! curve or surface, at a given tolerance, must generate the same uniform
+//! representation, regardless of where it is queried, and in which order.
+//!
+//! ## Implementation Note
+//!
+//! As of this writing, the transition from the previous, more limited, geometry
+//! system to the new one based on uniform representation is still ongoing. As a
+//! result of that, this module might still be incomplete.
+
+use std::ops::Deref;
+
+use fj_interop::Tolerance;
+use fj_math::{Aabb, LineSegment, Point, Scalar, Triangle};
+
+use super::{CurveBoundary, Geometry, Path};
+
+/// # Generate polylines, the uniform representation of curve geometry
+///
+/// This trait provides a generic and uniform interface to curve geometry. It is
+/// implemented by types that represent specific kinds of curve geometry.
+///
+/// It is generic over the dimensionality of the generated polyline. Typically,
+/// two variants should be implemented per curve geometry type:
+///
+/// - `GenPolyline<2>` for surface-local geometry.
+/// - `GenPolyline<3>` for global 3D geometry.
+pub trait GenPolyline<const D: usize> {
+    /// # Access the origin of the curve
+    fn origin(&self) -> Point<D>;
+
+    /// # Compute a line segment to approximate the curve at this point
+    ///
+    /// ## Degenerate Case
+    ///
+    /// If the curve requires no approximation (meaning it is a line), then per
+    /// convention, a degenerate line segment is returned, that collapses to the
+    /// provided point.
+    fn line_segment_at(
+        &self,
+        point_curve: Point<1>,
+        tolerance: Tolerance,
+    ) -> LineSegment<D>;
+
+    /// # Generate a polyline within the provided boundary
+    fn generate_polyline(
+        &self,
+        boundary: CurveBoundary<Point<1>>,
+        tolerance: Tolerance,
+    ) -> Vec<Point<1>>;
+}
+
+// This implementation is temporary, to ease the transition towards a curve
+// geometry trait. Eventually, `CurveGeom2` is expected to replace `Path`.
+impl<const D: usize> GenPolyline<D> for Path<D> {
+    fn origin(&self) -> Point<D> {
+        match self {
+            Self::Circle(circle) => circle.origin(),
+            Self::Line(line) => line.origin(),
+        }
+    }
+
+    fn line_segment_at(
+        &self,
+        point_curve: Point<1>,
+        tolerance: Tolerance,
+    ) -> LineSegment<D> {
+        match self {
+            Self::Circle(circle) => {
+                circle.line_segment_at(point_curve, tolerance)
+            }
+            Self::Line(line) => line.line_segment_at(point_curve, tolerance),
+        }
+    }
+
+    fn generate_polyline(
+        &self,
+        boundary: CurveBoundary<Point<1>>,
+        tolerance: Tolerance,
+    ) -> Vec<Point<1>> {
+        match self {
+            Self::Circle(circle) => {
+                circle.generate_polyline(boundary, tolerance)
+            }
+            Self::Line(line) => line.generate_polyline(boundary, tolerance),
+        }
+    }
+}
+
+/// # Generate triangle meshes, the uniform representation of surface geometry
+pub trait GenTriMesh {
+    /// # Access the origin of the surface
+    fn origin(&self, geometry: &Geometry) -> Point<3>;
+
+    /// # Return the triangle at the provided point on the surface
+    ///
+    /// Select a triangle of the surface's triangle mesh representation, the one
+    /// at the provided surface point. Return that triangle, as well as the
+    /// barycentric coordinates of the provided point on the triangle.
+    ///
+    /// ## Triangle Size and Validity
+    ///
+    /// If a surface is curved along both axes, the triangle's size is chosen
+    /// such, that it approximates the surface, with the maximum allowed
+    /// deviation of the actual surface defined by the provided tolerance
+    /// argument.
+    ///
+    /// Otherwise, the size of the returned triangle is at least partially
+    /// arbitrary. Take the extreme case of a plane: Since it is not curved at
+    /// all, the returned triangle can be arbitrarily large.
+    ///
+    /// However, since surfaces are infinite, and we can't represent infinite
+    /// triangles, there is no sensible upper bound for the size. Instead, to
+    /// prevent an arbitrary choice for the size of triangles, which would imply
+    /// properties of the surface that are not true, and might therefore be
+    /// confusing, the triangles returned by this function have a length of zero
+    /// along axes that do not require approximation.
+    ///
+    /// The most extreme case would be a plane, for which the returned triangle
+    /// is collapsed to a point. For a cylinder, the triangle would have the
+    /// appropriate width to approximate the curved axis given the provided
+    /// tolerance, while having zero height.
+    ///
+    /// ## Implementation Note
+    ///
+    /// At the time this was written, there was no dedicated type to represent
+    /// barycentric coordinates. Nor any other code that used them, I think.
+    ///
+    /// If this changes, and a special type for barycentric coordinates is
+    /// added, it would make sense to return that here.
+    fn triangle_at(
+        &self,
+        point_surface: Point<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> (Triangle<3>, [Scalar; 3]);
+
+    /// # Generated a triangle mesh within the provided boundary
+    fn generate_tri_mesh(
+        &self,
+        boundary: Aabb<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> Vec<Point<2>>;
+}
+
+impl<T> GenTriMesh for T
+where
+    T: Deref,
+    T::Target: GenTriMesh,
+{
+    fn origin(&self, geometry: &Geometry) -> Point<3> {
+        self.deref().origin(geometry)
+    }
+
+    fn triangle_at(
+        &self,
+        point_surface: Point<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> (Triangle<3>, [Scalar; 3]) {
+        self.deref().triangle_at(point_surface, tolerance, geometry)
+    }
+
+    fn generate_tri_mesh(
+        &self,
+        boundary: Aabb<2>,
+        tolerance: Tolerance,
+        geometry: &Geometry,
+    ) -> Vec<Point<2>> {
+        self.deref()
+            .generate_tri_mesh(boundary, tolerance, geometry)
+    }
+}

crates/fj-core/src/geometry/vertex.rs

@@ -0,0 +1,41 @@
+use std::collections::BTreeMap;
+
+use fj_math::Point;
+
+use crate::{storage::Handle, topology::Curve};
+
+/// The geometric definition of a vertex
+#[derive(Clone, Debug, Default)]
+pub struct VertexGeom {
+    /// # The redundant local definitions of the vertex geometry
+    ///
+    /// ## Implementation Note
+    ///
+    /// Having multiple redundant definitions is undesirable. However, we can't
+    /// just use one global definition in 3D, as we need the local 1D
+    /// definitions to approximate curves, and we currently don't have the tools
+    /// to project a global definition into a local context.
+    ///
+    /// Eventually, it should be possible to define the geometry of a vertex
+    /// once, either locally or globally, and then convert that single
+    /// definition into (other) local contexts, as needed. There currently is no
+    /// issue to track that specifically, but there is the following issue,
+    /// which is a prerequisite for making the required tooling practical:
+    ///
+    /// <https://github.com/hannobraun/fornjot/issues/2118>
+    pub definitions: BTreeMap<Handle<Curve>, LocalVertexGeom>,
+}
+
+impl VertexGeom {
+    /// # Return the local definition on the provided curve
+    pub fn local_on(&self, curve: &Handle<Curve>) -> Option<&LocalVertexGeom> {
+        self.definitions.get(curve)
+    }
+}
+
+/// The geometric definition of a vertex, in 1D curve coordinates
+#[derive(Clone, Debug)]
+pub struct LocalVertexGeom {
+    /// The position of the vertex, in 1-dimensional curve coordinates
+    pub position: Point<1>,
+}

crates/fj-core/src/layers/geometry.rs

@@ -1,48 +1,105 @@
 //! Layer infrastructure for [`Geometry`]
 
 use crate::{
-    geometry::{Geometry, HalfEdgeGeometry, SurfaceGeometry},
-    objects::{HalfEdge, Surface},
+    geometry::{
+        CurveGeom2, Geometry, LocalCurveGeom, LocalVertexGeom, SurfaceGeom,
+        surfaces::SweptCurve,
+    },
     storage::Handle,
+    topology::{Curve, Surface, Vertex},
 };
 
 use super::{Command, Event, Layer};
 
 impl Layer<Geometry> {
-    /// Define the geometry of the provided half-edge
-    pub fn define_half_edge(
+    /// Define the geometry of the provided curve
+    pub fn define_curve(
         &mut self,
-        half_edge: Handle<HalfEdge>,
-        geometry: HalfEdgeGeometry,
+        curve: Handle<Curve>,
+        surface: Handle<Surface>,
+        geometry: LocalCurveGeom,
     ) {
-        let mut events = Vec::new();
-        self.process(
-            DefineHalfEdge {
-                half_edge,
+        self.process_command(DefineCurve {
+            curve,
+            surface,
             geometry,
-            },
-            &mut events,
-        );
+        });
     }
 
-    /// Define the geometry of the provided surface
+    /// # Define the geometry of the provided curve
+    ///
+    /// ## Implementation Note
+    ///
+    /// There currently is an ongoing transition to a new geometry system. This
+    /// method defines new-style geometry. Its name is temporary, while the
+    /// method defining the old-style geometry is still taking up the more
+    /// concise name.
+    pub fn define_curve_2(
+        &mut self,
+        curve: Handle<Curve>,
+        geometry: CurveGeom2,
+    ) {
+        self.process_command(DefineCurve2 { curve, geometry });
+    }
+
+    /// # Define the geometry of the provided surface
+    ///
+    /// ## Panics
+    ///
+    /// Panics, if the surface is a special pre-defined plane, like the basis
+    /// planes (xy-, xz-, or yz-plane).
     pub fn define_surface(
         &mut self,
         surface: Handle<Surface>,
-        geometry: SurfaceGeometry,
+        geometry: SweptCurve,
     ) {
-        let mut events = Vec::new();
-        self.process(DefineSurface { surface, geometry }, &mut events);
+        self.process_command(DefineSurface { surface, geometry });
+    }
+
+    /// # Define the geometry of the provided surface
+    ///
+    /// ## Panics
+    ///
+    /// Panics, if the surface is a special pre-defined plane, like the basis
+    /// planes (xy-, xz-, or yz-plane).
+    ///
+    /// ## Implementation Note
+    ///
+    /// There currently is an ongoing transition to a new geometry system. This
+    /// method defines new-style geometry. Its name is temporary, while the
+    /// method defining the old-style geometry is still taking up the more
+    /// concise name.
+    pub fn define_surface_2(
+        &mut self,
+        surface: Handle<Surface>,
+        geometry: SurfaceGeom,
+    ) {
+        self.process_command(DefineSurface2 { surface, geometry });
+    }
+
+    /// Define the geometry of the provided vertex
+    pub fn define_vertex(
+        &mut self,
+        vertex: Handle<Vertex>,
+        curve: Handle<Curve>,
+        geometry: LocalVertexGeom,
+    ) {
+        self.process_command(DefineVertex {
+            vertex,
+            curve,
+            geometry,
+        });
     }
 }
 
-/// Define the geometry of a half-edge
-pub struct DefineHalfEdge {
-    half_edge: Handle<HalfEdge>,
-    geometry: HalfEdgeGeometry,
+/// Define the geometry of a curve
+pub struct DefineCurve {
+    curve: Handle<Curve>,
+    surface: Handle<Surface>,
+    geometry: LocalCurveGeom,
 }
 
-impl Command<Geometry> for DefineHalfEdge {
+impl Command<Geometry> for DefineCurve {
     type Result = ();
     type Event = Self;
 
@@ -55,16 +112,48 @@ impl Command<Geometry> for DefineHalfEdge {
     }
 }
 
-impl Event<Geometry> for DefineHalfEdge {
-    fn evolve(&self, state: &mut Geometry) {
-        state.define_half_edge_inner(self.half_edge.clone(), self.geometry);
+impl Event<Geometry> for DefineCurve {
+    fn evolve(self, state: &mut Geometry) {
+        state.define_curve_inner(self.curve, self.surface, self.geometry);
+    }
+}
+
+/// # Define the geometry of a curve
+///
+/// ## Implementation Note
+///
+/// There currently is an ongoing transition to a new geometry representation.
+/// This type is involved in defining the new-style geometry. Its name is
+/// temporary, while the respective type that defines old-style geometry is
+/// still taking up the more compact name.
+pub struct DefineCurve2 {
+    curve: Handle<Curve>,
+    geometry: CurveGeom2,
+}
+
+impl Command<Geometry> for DefineCurve2 {
+    type Result = ();
+    type Event = Self;
+
+    fn decide(
+        self,
+        _: &Geometry,
+        events: &mut Vec<Self::Event>,
+    ) -> Self::Result {
+        events.push(self);
+    }
+}
+
+impl Event<Geometry> for DefineCurve2 {
+    fn evolve(self, state: &mut Geometry) {
+        state.define_curve_inner_2(self.curve, self.geometry);
     }
 }
 
 /// Define the geometry of a surface
 pub struct DefineSurface {
     surface: Handle<Surface>,
-    geometry: SurfaceGeometry,
+    geometry: SweptCurve,
 }
 
 impl Command<Geometry> for DefineSurface {
@@ -81,7 +170,58 @@ impl Command<Geometry> for DefineSurface {
 }
 
 impl Event<Geometry> for DefineSurface {
-    fn evolve(&self, state: &mut Geometry) {
-        state.define_surface_inner(self.surface.clone(), self.geometry);
+    fn evolve(self, state: &mut Geometry) {
+        state.define_surface_inner(self.surface, self.geometry);
+    }
+}
+
+/// Define the geometry of a surface
+pub struct DefineSurface2 {
+    surface: Handle<Surface>,
+    geometry: SurfaceGeom,
+}
+
+impl Command<Geometry> for DefineSurface2 {
+    type Result = ();
+    type Event = Self;
+
+    fn decide(
+        self,
+        _: &Geometry,
+        events: &mut Vec<Self::Event>,
+    ) -> Self::Result {
+        events.push(self);
+    }
+}
+
+impl Event<Geometry> for DefineSurface2 {
+    fn evolve(self, state: &mut Geometry) {
+        state.define_surface_inner_2(self.surface, self.geometry);
+    }
+}
+
+/// Define the geometry of a curve
+pub struct DefineVertex {
+    vertex: Handle<Vertex>,
+    curve: Handle<Curve>,
+    geometry: LocalVertexGeom,
+}
+
+impl Command<Geometry> for DefineVertex {
+    type Result = ();
+    type Event = Self;
+
+    fn decide(
+        self,
+        _: &Geometry,
+        events: &mut Vec<Self::Event>,
+    ) -> Self::Result {
+        events.push(self);
+    }
+}
+
+impl Event<Geometry> for DefineVertex {
+    fn evolve(self, state: &mut Geometry) {
+        state.define_vertex_inner(self.vertex, self.curve, self.geometry);
     }
 }

crates/fj-core/src/layers/layer.rs

@@ -7,8 +7,8 @@ use std::ops::Deref;
 /// direct write access.
 ///
 /// Instead, each write access to state is reified as a command, which are
-/// processed by [`Layer::process`]. Processing a command can result in any
-/// number of events, which can then be used as commands for other layers.
+/// processed by [`Layer::process_command`]. Processing a command can result in
+/// any number of events, which can then be used as commands for other layers.
 ///
 /// This design takes inspiration from, and uses the nomenclature of, this
 /// article:
@@ -23,21 +23,40 @@ impl<S> Layer<S> {
         Self { state }
     }
 
-    /// Process a command
+    /// # Process a command without capturing any events
     ///
     /// The command is processed synchronously. When this method returns, the
     /// state has been updated.
-    pub fn process<C>(
+    pub fn process_command<C>(&mut self, command: C) -> C::Result
+    where
+        C: Command<S>,
+    {
+        let mut events = Vec::new();
+        let result = command.decide(&self.state, &mut events);
+
+        for event in events {
+            event.evolve(&mut self.state);
+        }
+
+        result
+    }
+
+    /// # Process a command and capture the events that produces
+    ///
+    /// The command is processed synchronously. When this method returns, the
+    /// state has been updated.
+    pub fn process_command_and_capture_events<C>(
         &mut self,
         command: C,
         events: &mut Vec<C::Event>,
     ) -> C::Result
     where
         C: Command<S>,
+        C::Event: Clone,
     {
         let result = command.decide(&self.state, events);
 
-        for event in events {
+        for event in events.iter().cloned() {
             event.evolve(&mut self.state);
         }
 
@@ -100,5 +119,5 @@ pub trait Event<S> {
     /// Implementations of this method are supposed to be relatively dumb. Any
     /// decisions that go into updating the state should be made in
     /// [`Command::decide`], and encoded into the event.
-    fn evolve(&self, state: &mut S);
+    fn evolve(self, state: &mut S);
 }

crates/fj-core/src/layers/layers.rs

@@ -1,7 +1,7 @@
 use crate::{
     geometry::Geometry,
-    objects::Objects,
     presentation::Presentation,
+    topology::Topology,
     validation::{Validation, ValidationConfig},
 };
 
@@ -22,11 +22,10 @@ use super::Layer;
 /// For now, there is no need for this, and all layers are just hardcoded here.
 /// That can be changed, once necessary.
 pub struct Layers {
-    /// The objects layer
+    /// The topology layer
     ///
-    /// Manages the stores of topological and geometric objects that make up
-    /// shapes.
-    pub objects: Layer<Objects>,
+    /// Manages the stores of topological objects.
+    pub topology: Layer<Topology>,
 
     /// The geometry layer
     ///
@@ -47,11 +46,11 @@ pub struct Layers {
 impl Layers {
     /// Construct an instance of `Layers`
     pub fn new() -> Self {
-        let objects = Objects::new();
-        let geometry = Geometry::new(&objects);
+        let topology = Topology::new();
+        let geometry = Geometry::new(&topology);
 
         Self {
-            objects: Layer::new(objects),
+            topology: Layer::new(topology),
             geometry: Layer::new(geometry),
             validation: Layer::default(),
             presentation: Layer::default(),

crates/fj-core/src/layers/mod.rs

@@ -3,8 +3,8 @@
 //! See [`Layers`].
 
 pub mod geometry;
-pub mod objects;
 pub mod presentation;
+pub mod topology;
 pub mod validation;
 
 mod layer;

crates/fj-core/src/layers/presentation.rs

@@ -3,9 +3,9 @@
 use fj_interop::Color;
 
 use crate::{
-    objects::{AnyObject, Region, Stored},
     presentation::Presentation,
     storage::Handle,
+    topology::{AnyObject, Region, Stored},
 };
 
 use super::{Command, Event, Layer};
@@ -13,8 +13,7 @@ use super::{Command, Event, Layer};
 impl Layer<Presentation> {
     /// Set the color of a region
     pub fn set_color(&mut self, region: Handle<Region>, color: Color) {
-        let mut events = Vec::new();
-        self.process(SetColor { region, color }, &mut events);
+        self.process_command(SetColor { region, color });
     }
 
     /// Mark an object as being derived from another
@@ -23,8 +22,7 @@ impl Layer<Presentation> {
         original: AnyObject<Stored>,
         derived: AnyObject<Stored>,
     ) {
-        let mut events = Vec::new();
-        self.process(DeriveObject { original, derived }, &mut events);
+        self.process_command(DeriveObject { original, derived });
     }
 }
 
@@ -51,7 +49,7 @@ impl Command<Presentation> for SetColor {
 }
 
 impl Event<Presentation> for SetColor {
-    fn evolve(&self, state: &mut Presentation) {
+    fn evolve(self, state: &mut Presentation) {
         state.color.insert(self.region.clone(), self.color);
     }
 }
@@ -77,9 +75,9 @@ impl Command<Presentation> for DeriveObject {
         if let (AnyObject::Region(original), AnyObject::Region(derived)) =
             (self.original, self.derived)
         {
-            if let Some(color) = state.color.get(&original.0).cloned() {
+            if let Some(color) = state.color.get(&original).cloned() {
                 events.push(SetColor {
-                    region: derived.into(),
+                    region: derived,
                     color,
                 });
             }

crates/fj-core/src/layers/topology.rs

@@ -1,32 +1,34 @@
-//! Layer infrastructure for [`Objects`]
+//! Layer infrastructure for [`Topology`]
 
 use crate::{
     geometry::Geometry,
-    objects::{AboutToBeStored, AnyObject, Objects},
+    topology::{AboutToBeStored, AnyObject, Topology},
     validation::Validation,
 };
 
-use super::{validation::ValidateObject, Command, Event, Layer};
+use super::{Command, Event, Layer, validation::ValidateObject};
 
-impl Layer<Objects> {
+impl Layer<Topology> {
     /// Insert an object into the stores
     ///
     /// Passes any events produced to the validation layer.
     pub fn insert(
         &mut self,
         object: AnyObject<AboutToBeStored>,
-        geometry: &Geometry,
+        geometry: &mut Layer<Geometry>,
         validation: &mut Layer<Validation>,
     ) {
         let mut events = Vec::new();
-        self.process(InsertObject { object }, &mut events);
+        self.process_command_and_capture_events(
+            InsertObject { object },
+            &mut events,
+        );
 
         for event in events {
-            let event = ValidateObject {
+            validation.process_command(ValidateObject {
                 object: event.object.into(),
                 geometry,
-            };
-            validation.process(event, &mut Vec::new());
+            });
         }
     }
 }
@@ -38,17 +40,17 @@ pub struct InsertObject {
     pub object: AnyObject<AboutToBeStored>,
 }
 
-impl Command<Objects> for InsertObject {
+impl Command<Topology> for InsertObject {
     type Result = ();
     type Event = InsertObject;
 
-    fn decide(self, _: &Objects, events: &mut Vec<Self::Event>) {
+    fn decide(self, _: &Topology, events: &mut Vec<Self::Event>) {
         events.push(self);
     }
 }
 
-impl Event<Objects> for InsertObject {
-    fn evolve(&self, state: &mut Objects) {
+impl Event<Topology> for InsertObject {
+    fn evolve(self, state: &mut Topology) {
         self.object.clone().insert(state);
     }
 }

crates/fj-core/src/layers/validation.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     geometry::Geometry,
-    objects::{AnyObject, Stored},
+    topology::{AnyObject, Stored},
     validation::{Validation, ValidationError, ValidationErrors},
 };
 
@@ -11,7 +11,7 @@ use super::{Command, Event, Layer};
 impl Layer<Validation> {
     /// Take all errors stored in the validation layer
     pub fn take_errors(&mut self) -> Result<(), ValidationErrors> {
-        self.process(TakeErrors, &mut Vec::new())
+        self.process_command(TakeErrors)
     }
 }
 
@@ -34,10 +34,11 @@ impl Command<Validation> for ValidateObject<'_> {
             .validate(&state.config, &mut errors, self.geometry);
 
         for err in errors {
-            events.push(ValidationFailed {
-                object: self.object.clone(),
-                err,
-            });
+            if state.config.panic_on_error {
+                panic!("{:#?}", err);
+            }
+
+            events.push(ValidationFailed { err });
         }
     }
 }
@@ -56,7 +57,7 @@ impl Command<Validation> for TakeErrors {
         state: &Validation,
         events: &mut Vec<Self::Event>,
     ) -> Self::Result {
-        let errors = ValidationErrors(state.errors.values().cloned().collect());
+        let errors = ValidationErrors(state.errors.to_vec());
 
         events.push(self);
 
@@ -69,7 +70,7 @@ impl Command<Validation> for TakeErrors {
 }
 
 impl Event<Validation> for TakeErrors {
-    fn evolve(&self, state: &mut Validation) {
+    fn evolve(self, state: &mut Validation) {
         state.errors.clear();
     }
 }
@@ -79,15 +80,12 @@ impl Event<Validation> for TakeErrors {
 /// Event produced by `Layer<Validation>`.
 #[derive(Clone)]
 pub struct ValidationFailed {
-    /// The object for which validation failed
-    pub object: AnyObject<Stored>,
-
     /// The validation error
     pub err: ValidationError,
 }
 
 impl Event<Validation> for ValidationFailed {
-    fn evolve(&self, state: &mut Validation) {
-        state.errors.insert(self.object.id(), self.err.clone());
+    fn evolve(self, state: &mut Validation) {
+        state.errors.push(self.err.clone());
     }
 }

crates/fj-core/src/lib.rs

@@ -81,14 +81,38 @@
 //!
 //! [Fornjot]: https://www.fornjot.app/
 
+// This Clippy lint warns about keys in maps and sets whose types have interior
+// mutability. This applies to `Handle`, which is why this lint triggers in
+// multiple places in this crate.
+//
+// These are false positives, however. As per the documentation of the lint[1],
+// These types are specifically okay to use, if their `Hash` and `Ord`
+// implementations do not rely on any fields that are not mutable. And for
+// `Handle`, those implementations only rely on the `Handle`s ID, which is
+// constant.
+//
+// I don't think I have ever personally encountered a bug that this lint would
+// have warned against. So I think it makes sense to, as a matter of
+// convenience, just disable the lint for the whole crate, instead of doing so
+// for every single false positive.
+//
+// It might be an even better option to configure Clippy to ignore `Handle`
+// specifically for this lint, which should be possible according to the lint
+// documentation.[1] For some reason this didn't work when I tried it, and I
+// couldn't figure out why. In the end, I decided it wasn't worth spending more
+// time on this, so this is the situation I ended up with.
+//
+// [1] https://rust-lang.github.io/rust-clippy/master/index.html#/mutable_key_type
+#![allow(clippy::mutable_key_type)]
+
 pub mod algorithms;
 pub mod geometry;
 pub mod layers;
-pub mod objects;
 pub mod operations;
 pub mod presentation;
 pub mod queries;
 pub mod storage;
+pub mod topology;
 pub mod validate;
 pub mod validation;
 

crates/fj-core/src/objects/kinds/half_edge.rs

@@ -1,89 +0,0 @@
-use fj_math::Point;
-
-use crate::{
-    geometry::{CurveBoundary, SurfacePath},
-    objects::{Curve, Vertex},
-    storage::{Handle, HandleWrapper},
-};
-
-/// # A directed half-edge, defined in a surface's 2D space
-///
-/// ## Structure
-///
-/// A `HalfEdge` is defined by the [`Curve`] it is on, its boundary on the
-/// curve, and the [`Vertex`] instances that bound it on the curve. To keep the
-/// data structures simple (by avoiding redundancy), each `HalfEdge` only refers
-/// to its start vertex. The vertex where it ends is referred to by the next
-/// `HalfEdge` in the [`Cycle`] that the `HalfEdge` is a part of.
-///
-///
-/// ## Validity
-///
-/// A valid `HalfEdge` must have a non-zero length, meaning its bounding
-/// vertices must not be coincident.
-///
-/// In a valid [`Shell`], `HalfEdge`s form coincident pairs, where the faces of
-/// the shell touch. The other `HalfEdge` in such a pair is called the sibling.
-///
-/// A `HalfEdge` and its sibling are equal but opposite. Specifically this means
-/// that both refer to the same curve; that the sibling has the same, but
-/// inverted, boundary; and that both are bound by the same vertices, though
-/// their start vertices are different.
-///
-///
-/// [`Cycle`]: crate::objects::Cycle
-/// [`Shell`]: crate::objects::Shell
-#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct HalfEdge {
-    path: SurfacePath,
-    boundary: CurveBoundary<Point<1>>,
-    curve: HandleWrapper<Curve>,
-    start_vertex: HandleWrapper<Vertex>,
-}
-
-impl HalfEdge {
-    /// Create an instance of `Edge`
-    pub fn new(
-        path: SurfacePath,
-        boundary: impl Into<CurveBoundary<Point<1>>>,
-        curve: Handle<Curve>,
-        start_vertex: Handle<Vertex>,
-    ) -> Self {
-        Self {
-            path,
-            boundary: boundary.into(),
-            curve: curve.into(),
-            start_vertex: start_vertex.into(),
-        }
-    }
-
-    /// Access the curve that defines the edge's geometry
-    pub fn path(&self) -> SurfacePath {
-        self.path
-    }
-
-    /// Access the boundary points of the edge on the curve
-    pub fn boundary(&self) -> CurveBoundary<Point<1>> {
-        self.boundary
-    }
-
-    /// Access the curve of the edge
-    pub fn curve(&self) -> &Handle<Curve> {
-        &self.curve
-    }
-
-    /// Access the vertex from where this edge starts
-    pub fn start_vertex(&self) -> &Handle<Vertex> {
-        &self.start_vertex
-    }
-
-    /// Compute the surface position where the edge starts
-    pub fn start_position(&self) -> Point<2> {
-        // Computing the surface position from the curve position is fine.
-        // `Edge` "owns" its start position. There is no competing code that
-        // could compute the surface position from slightly different data.
-
-        let [start, _] = self.boundary.inner;
-        self.path.point_from_path_coords(start)
-    }
-}

crates/fj-core/src/operations/build/curve.rs

@@ -0,0 +1,29 @@
+use crate::{
+    Core,
+    geometry::Path,
+    operations::{geometry::UpdateCurveGeometry, insert::Insert},
+    storage::Handle,
+    topology::{Curve, Surface},
+};
+
+/// Build a [`Curve`]
+///
+/// See [module-level documentation] for context.
+///
+/// [module-level documentation]: super
+pub trait BuildCurve {
+    /// Build a curve from the provided path and surface
+    fn from_path_and_surface(
+        path: Path<2>,
+        surface: Handle<Surface>,
+        core: &mut Core,
+    ) -> Handle<Curve> {
+        Curve::new().insert(core).make_path_on_surface(
+            path,
+            surface,
+            &mut core.layers.geometry,
+        )
+    }
+}
+
+impl BuildCurve for Curve {}

crates/fj-core/src/operations/build/cycle.rs

@@ -1,10 +1,12 @@
-use fj_math::{Point, Scalar};
+use fj_math::{Point, Scalar, Vector};
 use itertools::Itertools;
 
 use crate::{
-    objects::{Cycle, HalfEdge},
-    operations::{build::BuildHalfEdge, update::UpdateCycle},
     Core,
+    geometry::{CurveBoundary, LocalVertexGeom},
+    operations::build::BuildHalfEdge,
+    storage::Handle,
+    topology::{Cycle, HalfEdge, Surface},
 };
 
 /// Build a [`Cycle`]
@@ -18,32 +20,104 @@ pub trait BuildCycle {
         Cycle::new([])
     }
 
-    /// Build a circle
+    /// # Build a cycle from half-edges and associated curve boundaries
+    fn from_half_edges_and_boundaries<I>(
+        half_edges_and_boundaries: I,
+        core: &mut Core,
+    ) -> Cycle
+    where
+        I: IntoIterator<Item = (Handle<HalfEdge>, CurveBoundary<Point<1>>)>,
+        I::IntoIter: Clone + ExactSizeIterator,
+    {
+        let half_edges = half_edges_and_boundaries
+            .into_iter()
+            .circular_tuple_windows()
+            .map(|((half_edge, boundary), (next_half_edge, _))| {
+                let [start, end] = boundary.inner;
+
+                core.layers.geometry.define_vertex(
+                    half_edge.start_vertex().clone(),
+                    half_edge.curve().clone(),
+                    LocalVertexGeom { position: start },
+                );
+                core.layers.geometry.define_vertex(
+                    next_half_edge.start_vertex().clone(),
+                    half_edge.curve().clone(),
+                    LocalVertexGeom { position: end },
+                );
+
+                half_edge
+            });
+
+        Cycle::new(half_edges)
+    }
+
+    /// # Build a circle
+    ///
+    /// This circle is built out of 4 distinct arcs.
+    ///
+    /// ## Implementation Note
+    ///
+    /// The cycle can't be built out of a single half-edge. That would be
+    /// invalid although there's no validation check to document and enforce
+    /// that yet. Please refer to the following issue for more information:
+    /// <https://github.com/hannobraun/fornjot/issues/2374>
+    ///
+    /// The cycle is built out of 4 arcs specifically, because that's easier to
+    /// implement than three, and building it out of two creates geometry that
+    /// the cycle winding code can't handle right now. The following issue has
+    /// more information on the cycle winding problems:
+    /// <https://github.com/hannobraun/fornjot/issues/2130>
     fn circle(
         center: impl Into<Point<2>>,
         radius: impl Into<Scalar>,
+        surface: Handle<Surface>,
         core: &mut Core,
     ) -> Cycle {
-        let circle = HalfEdge::circle(center, radius, core);
-        Cycle::empty().add_half_edges([circle], core)
+        let center = center.into();
+        let radius = radius.into();
+
+        let radius_right = Vector::from([radius, Scalar::ZERO]);
+        let radius_up = Vector::from([Scalar::ZERO, radius]);
+
+        let a = center + radius_right;
+        let b = center + radius_up;
+        let c = center - radius_right;
+        let d = center - radius_up;
+
+        let angle = Scalar::TAU / 4.;
+
+        let half_edges_and_boundaries = [[a, b], [b, c], [c, d], [d, a]]
+            .into_iter()
+            .map(|[start, end]| {
+                HalfEdge::arc(start, end, angle, surface.clone(), core)
+            })
+            .collect::<Vec<_>>();
+
+        Self::from_half_edges_and_boundaries(half_edges_and_boundaries, core)
     }
 
     /// Build a polygon
-    fn polygon<P, Ps>(points: Ps, core: &mut Core) -> Cycle
+    fn polygon<P, Ps>(
+        points: Ps,
+        surface: Handle<Surface>,
+        core: &mut Core,
+    ) -> Cycle
     where
         P: Into<Point<2>>,
         Ps: IntoIterator<Item = P>,
         Ps::IntoIter: Clone + ExactSizeIterator,
     {
-        let edges = points
+        let half_edges_and_boundaries = points
             .into_iter()
             .map(Into::into)
             .circular_tuple_windows()
             .map(|(start, end)| {
-                HalfEdge::line_segment([start, end], None, core)
-            });
+                HalfEdge::line_segment([start, end], surface.clone(), core)
+            })
+            .collect::<Vec<_>>();
 
-        Cycle::new(edges)
+        Self::from_half_edges_and_boundaries(half_edges_and_boundaries, core)
     }
 }
 

crates/fj-core/src/operations/build/face.rs

@@ -1,16 +1,15 @@
 use std::{array, borrow::Borrow};
 
-use fj_interop::ext::ArrayExt;
 use fj_math::{Point, Scalar};
 
 use crate::{
-    objects::{Cycle, Face, HalfEdge, Region, Surface, Vertex},
+    Core,
     operations::{
         build::{BuildCycle, BuildRegion, BuildSurface},
         insert::{Insert, IsInserted, IsInsertedNo},
     },
     storage::Handle,
-    Core,
+    topology::{Cycle, Face, HalfEdge, Region, Surface, Vertex},
 };
 
 /// Build a [`Face`]
@@ -33,7 +32,8 @@ pub trait BuildFace {
         radius: impl Into<Scalar>,
         core: &mut Core,
     ) -> Face {
-        let region = Region::circle(center, radius, core).insert(core);
+        let region =
+            Region::circle(center, radius, surface.clone(), core).insert(core);
         Face::new(surface, region)
     }
 
@@ -60,7 +60,7 @@ pub trait BuildFace {
             array
         };
         let vertices = half_edges
-            .each_ref_ext()
+            .each_ref()
             .map(|edge: &Handle<HalfEdge>| edge.start_vertex().clone());
 
         Polygon {
@@ -81,7 +81,8 @@ pub trait BuildFace {
         Ps: IntoIterator<Item = P>,
         Ps::IntoIter: Clone + ExactSizeIterator,
     {
-        let region = Region::polygon(points, core).insert(core);
+        let region =
+            Region::polygon(points, surface.clone(), core).insert(core);
         Face::new(surface, region)
     }
 }

crates/fj-core/src/operations/build/half_edge.rs

@@ -1,12 +1,11 @@
-use fj_interop::ext::ArrayExt;
 use fj_math::{Arc, Point, Scalar};
 
 use crate::{
-    geometry::{CurveBoundary, HalfEdgeGeometry, SurfacePath},
-    objects::{Curve, HalfEdge, Vertex},
-    operations::insert::Insert,
-    storage::Handle,
     Core,
+    geometry::{CurveBoundary, LocalCurveGeom, Path},
+    operations::{geometry::UpdateCurveGeometry, insert::Insert},
+    storage::Handle,
+    topology::{Curve, HalfEdge, Surface, Vertex},
 };
 
 /// Build a [`HalfEdge`]
@@ -16,15 +15,11 @@ use crate::{
 /// [module-level documentation]: super
 pub trait BuildHalfEdge {
     /// Create a half-edge that is not joined to a sibling
-    fn unjoined(
-        path: SurfacePath,
-        boundary: impl Into<CurveBoundary<Point<1>>>,
-        core: &mut Core,
-    ) -> HalfEdge {
+    fn unjoined(core: &mut Core) -> HalfEdge {
         let curve = Curve::new().insert(core);
         let start_vertex = Vertex::new().insert(core);
 
-        HalfEdge::new(path, boundary, curve, start_vertex)
+        HalfEdge::new(curve, start_vertex)
     }
 
     /// Create a half-edge from its sibling
@@ -33,22 +28,7 @@ pub trait BuildHalfEdge {
         start_vertex: Handle<Vertex>,
         core: &mut Core,
     ) -> Handle<HalfEdge> {
-        let half_edge = HalfEdge::new(
-            core.layers.geometry.of_half_edge(sibling).path,
-            sibling.boundary().reverse(),
-            sibling.curve().clone(),
-            start_vertex,
-        )
-        .insert(core);
-
-        core.layers.geometry.define_half_edge(
-            half_edge.clone(),
-            HalfEdgeGeometry {
-                path: core.layers.geometry.of_half_edge(sibling).path,
-            },
-        );
-
-        half_edge
+        HalfEdge::new(sibling.curve().clone(), start_vertex).insert(core)
     }
 
     /// Create an arc
@@ -60,8 +40,9 @@ pub trait BuildHalfEdge {
         start: impl Into<Point<2>>,
         end: impl Into<Point<2>>,
         angle_rad: impl Into<Scalar>,
+        surface: Handle<Surface>,
         core: &mut Core,
-    ) -> Handle<HalfEdge> {
+    ) -> (Handle<HalfEdge>, CurveBoundary<Point<1>>) {
         let angle_rad = angle_rad.into();
         if angle_rad <= -Scalar::TAU || angle_rad >= Scalar::TAU {
             panic!("arc angle must be in the range (-2pi, 2pi) radians");
@@ -69,55 +50,41 @@ pub trait BuildHalfEdge {
 
         let arc = Arc::from_endpoints_and_angle(start, end, angle_rad);
 
-        let path =
-            SurfacePath::circle_from_center_and_radius(arc.center, arc.radius);
-        let boundary =
-            [arc.start_angle, arc.end_angle].map(|coord| Point::from([coord]));
+        let path = Path::circle_from_center_and_radius(arc.center, arc.radius);
+        let boundary = CurveBoundary {
+            inner: [arc.start_angle, arc.end_angle]
+                .map(|coord| Point::from([coord])),
+        };
 
-        let half_edge = HalfEdge::unjoined(path, boundary, core).insert(core);
-        core.layers
-            .geometry
-            .define_half_edge(half_edge.clone(), HalfEdgeGeometry { path });
+        let half_edge = HalfEdge::unjoined(core).insert(core);
 
-        half_edge
-    }
+        core.layers.geometry.define_curve(
+            half_edge.curve().clone(),
+            surface,
+            LocalCurveGeom { path },
+        );
 
-    /// Create a circle
-    fn circle(
-        center: impl Into<Point<2>>,
-        radius: impl Into<Scalar>,
-        core: &mut Core,
-    ) -> Handle<HalfEdge> {
-        let path = SurfacePath::circle_from_center_and_radius(center, radius);
-        let boundary =
-            [Scalar::ZERO, Scalar::TAU].map(|coord| Point::from([coord]));
-
-        let half_edge = HalfEdge::unjoined(path, boundary, core).insert(core);
-        core.layers
-            .geometry
-            .define_half_edge(half_edge.clone(), HalfEdgeGeometry { path });
-
-        half_edge
+        (half_edge, boundary)
     }
 
     /// Create a line segment
     fn line_segment(
         points_surface: [impl Into<Point<2>>; 2],
-        boundary: Option<[Point<1>; 2]>,
+        surface: Handle<Surface>,
         core: &mut Core,
-    ) -> Handle<HalfEdge> {
-        let boundary =
-            boundary.unwrap_or_else(|| [[0.], [1.]].map(Point::from));
-        let path = SurfacePath::line_from_points_with_coords(
-            boundary.zip_ext(points_surface),
+    ) -> (Handle<HalfEdge>, CurveBoundary<Point<1>>) {
+        let boundary = CurveBoundary::default();
+
+        let half_edge = HalfEdge::unjoined(core).insert(core);
+
+        half_edge.curve().clone().make_line_on_surface(
+            points_surface,
+            boundary,
+            surface.clone(),
+            &mut core.layers.geometry,
         );
 
-        let half_edge = HalfEdge::unjoined(path, boundary, core).insert(core);
-        core.layers
-            .geometry
-            .define_half_edge(half_edge.clone(), HalfEdgeGeometry { path });
-
-        half_edge
+        (half_edge, boundary)
     }
 }
 

crates/fj-core/src/operations/build/mod.rs

@@ -17,6 +17,7 @@
 //! the top-level object itself, but also to the other objects that make up its
 //! components.
 
+mod curve;
 mod cycle;
 mod face;
 mod half_edge;
@@ -27,6 +28,7 @@ mod solid;
 mod surface;
 
 pub use self::{
+    curve::BuildCurve,
     cycle::BuildCycle,
     face::{BuildFace, Polygon},
     half_edge::BuildHalfEdge,

crates/fj-core/src/operations/build/region.rs

@@ -1,9 +1,10 @@
 use fj_math::{Point, Scalar};
 
 use crate::{
-    objects::{Cycle, Region},
-    operations::{build::BuildCycle, insert::Insert},
     Core,
+    operations::{build::BuildCycle, insert::Insert},
+    storage::Handle,
+    topology::{Cycle, Region, Surface},
 };
 
 /// Build a [`Region`]
@@ -24,20 +25,26 @@ pub trait BuildRegion {
     fn circle(
         center: impl Into<Point<2>>,
         radius: impl Into<Scalar>,
+        surface: Handle<Surface>,
         core: &mut Core,
     ) -> Region {
-        let exterior = Cycle::circle(center, radius, core).insert(core);
+        let exterior =
+            Cycle::circle(center, radius, surface, core).insert(core);
         Region::new(exterior, [])
     }
 
     /// Build a polygon
-    fn polygon<P, Ps>(points: Ps, core: &mut Core) -> Region
+    fn polygon<P, Ps>(
+        points: Ps,
+        surface: Handle<Surface>,
+        core: &mut Core,
+    ) -> Region
     where
         P: Into<Point<2>>,
         Ps: IntoIterator<Item = P>,
         Ps::IntoIter: Clone + ExactSizeIterator,
     {
-        let exterior = Cycle::polygon(points, core).insert(core);
+        let exterior = Cycle::polygon(points, surface, core).insert(core);
         Region::new(exterior, [])
     }
 }

crates/fj-core/src/operations/build/shell.rs

@@ -4,11 +4,11 @@ use fj_interop::ext::ArrayExt;
 use fj_math::Point;
 
 use crate::{
-    geometry::CurveBoundary,
-    objects::{Curve, Face, HalfEdge, Shell, Surface, Vertex},
+    Core,
+    geometry::{CurveBoundary, LocalVertexGeom},
     operations::{
         build::{BuildFace, BuildHalfEdge, BuildSurface, Polygon},
-        geometry::UpdateHalfEdgeGeometry,
+        geometry::UpdateCurveGeometry,
         insert::{Insert, IsInserted, IsInsertedNo, IsInsertedYes},
         join::JoinCycle,
         reverse::ReverseCurveCoordinateSystems,
@@ -16,7 +16,7 @@ use crate::{
             UpdateCycle, UpdateFace, UpdateHalfEdge, UpdateRegion, UpdateShell,
         },
     },
-    Core,
+    topology::{Curve, Face, HalfEdge, Shell, Surface, Vertex},
 };
 
 /// Build a [`Shell`]
@@ -70,11 +70,7 @@ pub trait BuildShell {
                             .cloned()
                             .unwrap_or_else(|| {
                                 let curve = Curve::new().insert(core);
-                                let boundary =
-                                    CurveBoundary::<Point<1>>::from([
-                                        [0.],
-                                        [1.],
-                                    ]);
+                                let boundary = CurveBoundary::default();
 
                                 curves.insert(
                                     vertices,
@@ -86,29 +82,49 @@ pub trait BuildShell {
                     });
 
                 let half_edges = {
-                    let vertices = [a, b, c].map(Clone::clone);
+                    let vertices = [[a, b], [b, c], [c, a]];
                     let [a, b, c] = [[0., 0.], [1., 0.], [0., 1.]];
                     vertices
                         .zip_ext([[a, b], [b, c], [c, a]])
                         .zip_ext(curves_and_boundaries)
-                        .map(|((vertex, positions), (curve, boundary))| {
-                            let half_edge = HalfEdge::line_segment(
+                        .map(
+                            |(
+                                ([vertex, vertex_next], positions),
+                                (curve, boundary),
+                            )| {
+                                let boundary = boundary.reverse();
+
+                                let curve = curve.make_line_on_surface(
                                     positions,
-                                Some(boundary.reverse().inner),
-                                core,
-                            );
-                            half_edge
-                                .update_start_vertex(|_, _| vertex, core)
-                                .update_curve(|_, _| curve, core)
-                                .insert(core)
-                                .set_path(
-                                    core.layers
-                                        .geometry
-                                        .of_half_edge(&half_edge)
-                                        .path,
+                                    boundary,
+                                    surface.clone(),
                                     &mut core.layers.geometry,
+                                );
+
+                                core.layers.geometry.define_vertex(
+                                    vertex.clone(),
+                                    curve.clone(),
+                                    LocalVertexGeom {
+                                        position: boundary.inner[0],
+                                    },
+                                );
+                                core.layers.geometry.define_vertex(
+                                    vertex_next.clone(),
+                                    curve.clone(),
+                                    LocalVertexGeom {
+                                        position: boundary.inner[1],
+                                    },
+                                );
+
+                                HalfEdge::unjoined(core)
+                                    .update_start_vertex(
+                                        |_, _| vertex.clone(),
+                                        core,
+                                    )
+                                    .update_curve(|_, _| curve.clone(), core)
+                                    .insert(core)
+                            },
                         )
-                        })
                 };
 
                 Face::unbound(surface, core).update_region(
@@ -153,16 +169,27 @@ pub trait BuildShell {
         let [a, b, c, d] = points.map(Into::into);
 
         let abc = Face::triangle([a, b, c], core);
-        let bad = Face::triangle([b, a, d], core).update_region(
+        let bad = {
+            let bad = Face::triangle([b, a, d], core);
+            bad.update_region(
                 |region, core| {
                     region.update_exterior(
                         |cycle, core| {
                             cycle
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(0),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(1)
+                                                .start_vertex(),
+                                            bad.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
@@ -170,6 +197,7 @@ pub trait BuildShell {
                                     abc.face.region().exterior(),
                                     0..=0,
                                     0..=0,
+                                    bad.face.surface().clone(),
                                     core,
                                 )
                         },
@@ -177,17 +205,29 @@ pub trait BuildShell {
                     )
                 },
                 core,
-        );
-        let dac = Face::triangle([d, a, c], core).update_region(
+            )
+        };
+        let dac = {
+            let dac = Face::triangle([d, a, c], core);
+            dac.update_region(
                 |region, core| {
                     region.update_exterior(
                         |cycle, core| {
                             cycle
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(1),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(2)
+                                                .start_vertex(),
+                                            dac.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
@@ -195,13 +235,23 @@ pub trait BuildShell {
                                     abc.face.region().exterior(),
                                     1..=1,
                                     2..=2,
+                                    dac.face.surface().clone(),
                                     core,
                                 )
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(0),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(1)
+                                                .start_vertex(),
+                                            dac.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
@@ -209,6 +259,7 @@ pub trait BuildShell {
                                     bad.face.region().exterior(),
                                     0..=0,
                                     1..=1,
+                                    dac.face.surface().clone(),
                                     core,
                                 )
                         },
@@ -216,33 +267,63 @@ pub trait BuildShell {
                     )
                 },
                 core,
-        );
-        let cbd = Face::triangle([c, b, d], core).update_region(
+            )
+        };
+        let cbd = {
+            let cbd = Face::triangle([c, b, d], core);
+            cbd.update_region(
                 |region, core| {
                     region.update_exterior(
                         |cycle, core| {
                             cycle
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(0),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(1)
+                                                .start_vertex(),
+                                            cbd.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(1),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(2)
+                                                .start_vertex(),
+                                            cbd.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
                                 .update_half_edge(
                                     cycle.half_edges().nth_circular(2),
-                                |edge, core| {
-                                    [edge
-                                        .reverse_curve_coordinate_systems(core)]
+                                    |half_edge, core| {
+                                        [(
+                                            half_edge,
+                                            cycle
+                                                .half_edges()
+                                                .nth_circular(3)
+                                                .start_vertex(),
+                                            cbd.face.surface(),
+                                        )
+                                            .reverse_curve_coordinate_systems(
+                                                core,
+                                            )]
                                     },
                                     core,
                                 )
@@ -250,18 +331,21 @@ pub trait BuildShell {
                                     abc.face.region().exterior(),
                                     0..=0,
                                     1..=1,
+                                    cbd.face.surface().clone(),
                                     core,
                                 )
                                 .join_to(
                                     bad.face.region().exterior(),
                                     1..=1,
                                     2..=2,
+                                    cbd.face.surface().clone(),
                                     core,
                                 )
                                 .join_to(
                                     dac.face.region().exterior(),
                                     2..=2,
                                     2..=2,
+                                    cbd.face.surface().clone(),
                                     core,
                                 )
                         },
@@ -269,7 +353,8 @@ pub trait BuildShell {
                     )
                 },
                 core,
-        );
+            )
+        };
 
         let triangles =
             [abc, bad, dac, cbd].map(|triangle| triangle.insert(core));

crates/fj-core/src/operations/build/sketch.rs

@@ -1,4 +1,12 @@
-use crate::objects::Sketch;
+use fj_math::{Point, Scalar};
+
+use crate::{
+    Core,
+    operations::update::UpdateSketch,
+    topology::{Region, Sketch, Topology},
+};
+
+use super::BuildRegion;
 
 /// Build a [`Sketch`]
 ///
@@ -7,8 +15,40 @@ use crate::objects::Sketch;
 /// [module-level documentation]: super
 pub trait BuildSketch {
     /// Create a sketch with no regions
-    fn empty() -> Sketch {
-        Sketch::new([])
+    fn empty(topology: &Topology) -> Sketch {
+        Sketch::new(topology.surfaces.space_2d(), [])
+    }
+
+    /// Build a circle
+    fn circle(
+        center: impl Into<Point<2>>,
+        radius: impl Into<Scalar>,
+        core: &mut Core,
+    ) -> Sketch {
+        let sketch = Sketch::empty(&core.layers.topology);
+        sketch.add_regions(
+            [Region::circle(
+                center,
+                radius,
+                sketch.surface().clone(),
+                core,
+            )],
+            core,
+        )
+    }
+
+    /// Build a polygon
+    fn polygon<P, Ps>(points: Ps, core: &mut Core) -> Sketch
+    where
+        P: Into<Point<2>>,
+        Ps: IntoIterator<Item = P>,
+        Ps::IntoIter: Clone + ExactSizeIterator,
+    {
+        let sketch = Sketch::empty(&core.layers.topology);
+        sketch.add_regions(
+            [Region::polygon(points, sketch.surface().clone(), core)],
+            core,
+        )
     }
 }
 

crates/fj-core/src/operations/build/solid.rs

@@ -1,13 +1,13 @@
 use fj_math::Point;
 
 use crate::{
-    objects::{Shell, Solid},
+    Core,
     operations::{
         build::{BuildShell, TetrahedronShell},
         insert::{Insert, IsInsertedYes},
         update::UpdateSolid,
     },
-    Core,
+    topology::{Shell, Solid},
 };
 
 /// Build a [`Solid`]

crates/fj-core/src/operations/build/surface.rs

@@ -1,11 +1,13 @@
 use fj_math::{Point, Scalar, Vector};
 
 use crate::{
-    geometry::{GlobalPath, SurfaceGeometry},
-    objects::Surface,
+    Core,
+    geometry::{
+        Path, SurfaceGeom, repr::tri_mesh::TriMesh, surfaces::SweptCurve,
+    },
     operations::insert::Insert,
     storage::Handle,
-    Core,
+    topology::Surface,
 };
 
 /// Build a [`Surface`]
@@ -14,6 +16,42 @@ use crate::{
 ///
 /// [module-level documentation]: super
 pub trait BuildSurface {
+    /// Build a surface from the provided geometry
+    fn from_geometry(
+        generator: SweptCurve,
+        core: &mut Core,
+    ) -> Handle<Surface> {
+        let surface = Surface::new().insert(core);
+
+        core.layers
+            .geometry
+            .define_surface(surface.clone(), generator);
+        core.layers.geometry.define_surface_2(
+            surface.clone(),
+            SurfaceGeom {
+                generator: Box::new(generator),
+                geometry: TriMesh::empty(),
+            },
+        );
+
+        surface
+    }
+
+    /// Build a surface from the provided `u` and `v`
+    fn from_uv(
+        u: impl Into<Path<3>>,
+        v: impl Into<Vector<3>>,
+        core: &mut Core,
+    ) -> Handle<Surface> {
+        Self::from_geometry(
+            SweptCurve {
+                u: u.into(),
+                v: v.into(),
+            },
+            core,
+        )
+    }
+
     /// Build a plane from the provided points
     fn plane_from_points(
         points: [impl Into<Point<3>>; 3],
@@ -21,10 +59,10 @@ pub trait BuildSurface {
     ) -> (Handle<Surface>, [Point<2>; 3]) {
         let [a, b, c] = points.map(Into::into);
 
-        let (u, u_line) = GlobalPath::line_from_points([a, b]);
+        let (u, u_line) = Path::line_from_points([a, b]);
         let v = c - a;
 
-        let surface = Surface::surface_from_uv(u, v, core);
+        let surface = Surface::from_uv(u, v, core);
 
         let points_surface = {
             let [a, b] =
@@ -36,25 +74,6 @@ pub trait BuildSurface {
 
         (surface, points_surface)
     }
-
-    /// Build a plane from the provided `u` and `v`
-    fn surface_from_uv(
-        u: impl Into<GlobalPath>,
-        v: impl Into<Vector<3>>,
-        core: &mut Core,
-    ) -> Handle<Surface> {
-        let surface = Surface::new().insert(core);
-
-        core.layers.geometry.define_surface(
-            surface.clone(),
-            SurfaceGeometry {
-                u: u.into(),
-                v: v.into(),
-            },
-        );
-
-        surface
-    }
 }
 
 impl BuildSurface for Surface {}

crates/fj-core/src/operations/derive.rs

@@ -3,9 +3,9 @@
 //! See [`DeriveFrom`].
 
 use crate::{
-    objects::{AnyObject, Stored},
-    storage::Handle,
     Core,
+    storage::Handle,
+    topology::{AnyObject, Stored},
 };
 
 /// Mark a store object as derived from another

crates/fj-core/src/operations/geometry/curve.rs

@@ -0,0 +1,84 @@
+use fj_interop::ext::ArrayExt;
+use fj_math::Point;
+
+use crate::{
+    geometry::{CurveBoundary, Geometry, LocalCurveGeom, Path},
+    layers::Layer,
+    storage::Handle,
+    topology::{Curve, Surface},
+};
+
+/// Update the geometry of a [`Curve`]
+pub trait UpdateCurveGeometry {
+    /// Copy the geometry of the provided curve
+    fn copy_geometry_from(
+        self,
+        curve: &Handle<Curve>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self;
+
+    /// Define the geometry as a path on a surface
+    fn make_path_on_surface(
+        self,
+        path: Path<2>,
+        surface: Handle<Surface>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self;
+
+    /// Define the geometry as a line
+    ///
+    /// The line is constructed from two points on the provided surface.
+    ///
+    /// Optionally the coordinates of those points on the curve can be supplied.
+    /// If those are not provided, it is assumed that the provided surface
+    /// points have the curve coordinates `0` and `1`.
+    fn make_line_on_surface(
+        self,
+        points_surface: [impl Into<Point<2>>; 2],
+        points_curve: CurveBoundary<Point<1>>,
+        surface: Handle<Surface>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self;
+}
+
+impl UpdateCurveGeometry for Handle<Curve> {
+    fn copy_geometry_from(
+        self,
+        curve: &Handle<Curve>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self {
+        let curve_geom = geometry.of_curve(curve).cloned();
+        if let Some(curve_geom) = curve_geom {
+            for (surface, local_definition) in curve_geom.definitions {
+                geometry.define_curve(self.clone(), surface, local_definition);
+            }
+        }
+
+        self
+    }
+
+    fn make_path_on_surface(
+        self,
+        path: Path<2>,
+        surface: Handle<Surface>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self {
+        geometry.define_curve(self.clone(), surface, LocalCurveGeom { path });
+
+        self
+    }
+
+    fn make_line_on_surface(
+        self,
+        points_surface: [impl Into<Point<2>>; 2],
+        points_curve: CurveBoundary<Point<1>>,
+        surface: Handle<Surface>,
+        geometry: &mut Layer<Geometry>,
+    ) -> Self {
+        let path = Path::line_from_points_with_coords(
+            points_curve.inner.zip_ext(points_surface),
+        );
+
+        self.make_path_on_surface(path, surface, geometry)
+    }
+}

crates/fj-core/src/operations/geometry/half_edge.rs

@@ -1,83 +0,0 @@
-use fj_math::Point;
-
-use crate::{
-    geometry::{CurveBoundary, Geometry, HalfEdgeGeometry, SurfacePath},
-    layers::Layer,
-    objects::HalfEdge,
-    operations::insert::Insert,
-    storage::Handle,
-    Core,
-};
-
-/// Update the geometry of a [`HalfEdge`]
-pub trait UpdateHalfEdgeGeometry {
-    /// Set the path of the half-edge
-    fn set_path(
-        self,
-        path: SurfacePath,
-        geometry: &mut Layer<Geometry>,
-    ) -> Self;
-
-    /// Update the path of the half-edge
-    #[must_use]
-    fn update_path(
-        &self,
-        update: impl FnOnce(SurfacePath) -> SurfacePath,
-        core: &mut Core,
-    ) -> Self;
-
-    /// Update the boundary of the half-edge
-    #[must_use]
-    fn update_boundary(
-        &self,
-        update: impl FnOnce(CurveBoundary<Point<1>>) -> CurveBoundary<Point<1>>,
-        core: &mut Core,
-    ) -> Self;
-}
-
-impl UpdateHalfEdgeGeometry for Handle<HalfEdge> {
-    fn set_path(
-        self,
-        path: SurfacePath,
-        geometry: &mut Layer<Geometry>,
-    ) -> Self {
-        geometry.define_half_edge(self.clone(), HalfEdgeGeometry { path });
-        self
-    }
-
-    fn update_path(
-        &self,
-        update: impl FnOnce(SurfacePath) -> SurfacePath,
-        core: &mut Core,
-    ) -> Self {
-        let path = update(core.layers.geometry.of_half_edge(self).path);
-
-        let half_edge = HalfEdge::new(
-            path,
-            self.boundary(),
-            self.curve().clone(),
-            self.start_vertex().clone(),
-        )
-        .insert(core);
-
-        core.layers
-            .geometry
-            .define_half_edge(half_edge.clone(), HalfEdgeGeometry { path });
-
-        half_edge
-    }
-
-    fn update_boundary(
-        &self,
-        update: impl FnOnce(CurveBoundary<Point<1>>) -> CurveBoundary<Point<1>>,
-        core: &mut Core,
-    ) -> Self {
-        HalfEdge::new(
-            core.layers.geometry.of_half_edge(self).path,
-            update(self.boundary()),
-            self.curve().clone(),
-            self.start_vertex().clone(),
-        )
-        .insert(core)
-    }
-}

crates/fj-core/src/operations/geometry/mod.rs

@@ -1,5 +1,5 @@
 //! Operations to update the geometry of objects
 
-mod half_edge;
+mod curve;
 
-pub use self::half_edge::UpdateHalfEdgeGeometry;
+pub use self::curve::UpdateCurveGeometry;

crates/fj-core/src/operations/holes.rs

@@ -3,16 +3,16 @@
 use fj_math::{Point, Scalar, Vector};
 
 use crate::{
-    objects::{Cycle, Face, HalfEdge, Region, Shell},
-    storage::Handle,
     Core,
+    geometry::repr::tri_mesh::convert_point_surface_to_global,
+    storage::Handle,
+    topology::{Cycle, Face, Region, Shell},
 };
 
 use super::{
-    build::{BuildCycle, BuildHalfEdge, BuildRegion},
-    join::JoinCycle,
+    build::{BuildCycle, BuildRegion},
     sweep::{SweepCache, SweepRegion},
-    update::{UpdateCycle, UpdateFace, UpdateRegion, UpdateShell},
+    update::{UpdateFace, UpdateRegion, UpdateShell},
 };
 
 /// Add a hole to a [`Shell`]
@@ -43,14 +43,16 @@ impl AddHole for Shell {
         path: impl Into<Vector<3>>,
         core: &mut Core,
     ) -> Self {
-        let entry = HalfEdge::circle(location.position, radius, core);
-        let hole = Region::empty(core)
-            .update_exterior(
-                |_, core| Cycle::empty().add_half_edges([entry.clone()], core),
+        let entry = Cycle::circle(
+            location.position,
+            radius,
+            location.face.surface().clone(),
             core,
-            )
+        );
+        let hole = Region::empty(core)
+            .update_exterior(|_, _| entry.clone(), core)
             .sweep_region(
-                location.face.surface(),
+                location.face.surface().clone(),
                 None,
                 path,
                 &mut SweepCache::default(),
@@ -63,22 +65,7 @@ impl AddHole for Shell {
             location.face,
             |face, core| {
                 [face.update_region(
-                    |region, core| {
-                        region.add_interiors(
-                            [Cycle::empty().add_joined_edges(
-                                [(
-                                    entry.clone(),
-                                    core.layers
-                                        .geometry
-                                        .of_half_edge(&entry)
-                                        .path,
-                                    entry.boundary(),
-                                )],
-                                core,
-                            )],
-                            core,
-                        )
-                    },
+                    |region, core| region.add_interiors([entry], core),
                     core,
                 )]
             },
@@ -95,14 +82,26 @@ impl AddHole for Shell {
     ) -> Self {
         let radius = radius.into();
 
-        let entry = HalfEdge::circle(entry_location.position, radius, core);
+        let entry = Cycle::circle(
+            entry_location.position,
+            radius,
+            entry_location.face.surface().clone(),
+            core,
+        );
 
         let path = {
             let point = |location: &HoleLocation| {
-                core.layers
+                convert_point_surface_to_global(
+                    &core
+                        .layers
                         .geometry
-                    .of_surface(location.face.surface())
-                    .point_from_surface_coords(location.position)
+                        .of_surface_2(location.face.surface())
+                        .unwrap()
+                        .generator,
+                    location.position,
+                    core.tolerance(),
+                    &core.layers.geometry,
+                )
             };
 
             let entry_point = point(&entry_location);
@@ -112,12 +111,9 @@ impl AddHole for Shell {
         };
 
         let swept_region = Region::empty(core)
-            .update_exterior(
-                |_, core| Cycle::empty().add_half_edges([entry.clone()], core),
-                core,
-            )
+            .update_exterior(|_, _| entry.clone(), core)
             .sweep_region(
-                entry_location.face.surface(),
+                entry_location.face.surface().clone(),
                 None,
                 path,
                 &mut SweepCache::default(),
@@ -126,33 +122,13 @@ impl AddHole for Shell {
 
         let hole = swept_region.side_faces.into_iter().collect::<Vec<_>>();
 
-        let exit = swept_region
-            .top_face
-            .region()
-            .exterior()
-            .half_edges()
-            .only();
+        let exit = swept_region.top_face.region().exterior();
 
         self.update_face(
             entry_location.face,
             |face, core| {
                 [face.update_region(
-                    |region, core| {
-                        region.add_interiors(
-                            [Cycle::empty().add_joined_edges(
-                                [(
-                                    entry.clone(),
-                                    core.layers
-                                        .geometry
-                                        .of_half_edge(&entry)
-                                        .path,
-                                    entry.boundary(),
-                                )],
-                                core,
-                            )],
-                            core,
-                        )
-                    },
+                    |region, core| region.add_interiors([entry], core),
                     core,
                 )]
             },
@@ -163,20 +139,21 @@ impl AddHole for Shell {
             |face, core| {
                 [face.update_region(
                     |region, core| {
-                        region.add_interiors(
-                            [Cycle::empty().add_joined_edges(
-                                [(
-                                    exit.clone(),
-                                    core.layers
+                        for half_edge in exit.half_edges() {
+                            let geometry = core
+                                .layers
                                 .geometry
-                                        .of_half_edge(exit)
-                                        .path,
-                                    exit.boundary(),
-                                )],
-                                core,
-                            )],
-                            core,
-                        )
+                                .of_curve(half_edge.curve())
+                                .unwrap()
+                                .local_on(swept_region.top_face.surface())
+                                .unwrap();
+                            core.layers.geometry.define_curve(
+                                half_edge.curve().clone(),
+                                exit_location.face.surface().clone(),
+                                geometry.clone(),
+                            );
+                        }
+                        region.add_interiors([exit.clone()], core)
                     },
                     core,
                 )]

crates/fj-core/src/operations/insert/insert_trait.rs

@@ -1,11 +1,11 @@
 use crate::{
-    objects::{
+    Core,
+    operations::build::{Polygon, TetrahedronShell},
+    storage::Handle,
+    topology::{
         Curve, Cycle, Face, HalfEdge, Region, Shell, Sketch, Solid, Surface,
         Vertex,
     },
-    operations::build::{Polygon, TetrahedronShell},
-    storage::Handle,
-    Core,
 };
 
 use super::{IsInsertedNo, IsInsertedYes};
@@ -38,11 +38,11 @@ macro_rules! impl_insert {
                 type Inserted = Handle<Self>;
 
                 fn insert(self, core: &mut Core) -> Self::Inserted {
-                    let handle = core.layers.objects.$store.reserve();
+                    let handle = core.layers.topology.$store.reserve();
                     let object = (handle.clone(), self).into();
-                    core.layers.objects.insert(
+                    core.layers.topology.insert(
                         object,
-                        &core.layers.geometry,
+                        &mut core.layers.geometry,
                         &mut core.layers.validation,
                     );
                     handle

crates/fj-core/src/operations/join/cycle.rs

@@ -1,30 +1,43 @@
 use std::ops::RangeInclusive;
 
-use fj_math::Point;
 use itertools::Itertools;
 
 use crate::{
-    geometry::{CurveBoundary, HalfEdgeGeometry, SurfacePath},
-    objects::{Cycle, HalfEdge},
+    Core,
+    geometry::LocalCurveGeom,
     operations::{
         build::BuildHalfEdge,
-        geometry::UpdateHalfEdgeGeometry,
         insert::Insert,
         update::{UpdateCycle, UpdateHalfEdge},
     },
     storage::Handle,
-    Core,
+    topology::{Cycle, HalfEdge, Surface},
 };
 
 /// Join a [`Cycle`] to another
 pub trait JoinCycle {
-    /// Add half-edges to the cycle that are joined to the provided ones
+    /// Add new half-edges to the cycle that are joined to the provided ones
+    ///
+    /// This method creates a new half-edge for each half-edge that is provided,
+    /// joins the new half-edge to the provided one, and adds the new half-edge
+    /// to the cycle.
+    ///
+    /// Expects the provided half-edges to be in an unnatural order:
+    ///
+    /// - This is the opposite order that they would appear in, in a cycle.
+    /// - Meaning each half-edge ends where the _previous_ one starts.
+    ///
+    /// The geometry for each new half-edge needs to be provided as well. Also
+    /// requires the surface that the cycle is defined in.
     #[must_use]
-    fn add_joined_edges<Es>(&self, edges: Es, core: &mut Core) -> Self
+    fn add_joined_half_edges<Es>(
+        &self,
+        half_edges: Es,
+        surface: Handle<Surface>,
+        core: &mut Core,
+    ) -> Self
     where
-        Es: IntoIterator<
-            Item = (Handle<HalfEdge>, SurfacePath, CurveBoundary<Point<1>>),
-        >,
+        Es: IntoIterator<Item = (Handle<HalfEdge>, LocalCurveGeom)>,
         Es::IntoIter: Clone + ExactSizeIterator;
 
     /// Join the cycle to another
@@ -74,33 +87,42 @@ pub trait JoinCycle {
         other: &Cycle,
         range: RangeInclusive<usize>,
         other_range: RangeInclusive<usize>,
+        surface_self: Handle<Surface>,
         core: &mut Core,
     ) -> Self;
 }
 
 impl JoinCycle for Cycle {
-    fn add_joined_edges<Es>(&self, edges: Es, core: &mut Core) -> Self
+    fn add_joined_half_edges<Es>(
+        &self,
+        half_edges: Es,
+        surface: Handle<Surface>,
+        core: &mut Core,
+    ) -> Self
     where
-        Es: IntoIterator<
-            Item = (Handle<HalfEdge>, SurfacePath, CurveBoundary<Point<1>>),
-        >,
+        Es: IntoIterator<Item = (Handle<HalfEdge>, LocalCurveGeom)>,
         Es::IntoIter: Clone + ExactSizeIterator,
     {
-        let half_edges = edges
+        let half_edges = half_edges
             .into_iter()
             .circular_tuple_windows()
-            .map(|((prev_half_edge, _, _), (half_edge, path, boundary))| {
-                let half_edge = HalfEdge::unjoined(path, boundary, core)
+            // If you're confused about the naming of `next_half_edge` and/or
+            // the relative order of `half_edge`/`next_half_edge`, please refer
+            // to the documentation of this method. This matches the order it
+            // expects half-edges in.
+            .map(|((next_half_edge, _), (half_edge, curve_geom))| {
+                let half_edge = HalfEdge::unjoined(core)
                     .update_curve(|_, _| half_edge.curve().clone(), core)
                     .update_start_vertex(
-                        |_, _| prev_half_edge.start_vertex().clone(),
+                        |_, _| next_half_edge.start_vertex().clone(),
                         core,
                     )
                     .insert(core);
 
-                core.layers.geometry.define_half_edge(
-                    half_edge.clone(),
-                    HalfEdgeGeometry { path },
+                core.layers.geometry.define_curve(
+                    half_edge.curve().clone(),
+                    surface.clone(),
+                    curve_geom,
                 );
 
                 half_edge
@@ -114,6 +136,7 @@ impl JoinCycle for Cycle {
         other: &Cycle,
         range: RangeInclusive<usize>,
         range_other: RangeInclusive<usize>,
+        surface_self: Handle<Surface>,
         core: &mut Core,
     ) -> Self {
         assert_eq!(
@@ -125,54 +148,145 @@ impl JoinCycle for Cycle {
         range.zip(range_other).fold(
             self.clone(),
             |cycle, (index, index_other)| {
-                let edge_other = other.half_edges().nth_circular(index_other);
+                let half_edge = self.half_edges().nth_circular(index);
+                let half_edge_next = self.half_edges().nth_circular(index + 1);
+                let half_edge_other =
+                    other.half_edges().nth_circular(index_other);
+                let half_edge_other_next =
+                    other.half_edges().nth_circular(index_other + 1);
 
                 cycle
                     .update_half_edge(
-                        self.half_edges().nth_circular(index),
+                        half_edge,
                         |half_edge, core| {
+                            // The curve of the other half-edge we're joining
+                            // this one to already has a curve geometry,
+                            // presumably. But it might not have a local
+                            // definition for the surface that *this* half-edge
+                            // is in.
+                            //
+                            // We need to make sure that any local definition
+                            // that our current curve already has, moves over to
+                            // the new one.
+                            let curve_geom = core
+                                .layers
+                                .geometry
+                                .of_curve(half_edge.curve())
+                                .and_then(|curve_geom| {
+                                    curve_geom.local_on(&surface_self)
+                                });
+                            if let Some(curve_geom) = curve_geom {
+                                core.layers.geometry.define_curve(
+                                    half_edge_other.curve().clone(),
+                                    surface_self.clone(),
+                                    curve_geom.clone(),
+                                );
+                            }
+
+                            // The same goes for vertices. We have to move over
+                            // any local definitions we have to the other
+                            // vertices.
+                            let vertex_geom_prev_end = core
+                                .layers
+                                .geometry
+                                .of_vertex(half_edge.start_vertex())
+                                .and_then(|vertex_geom| {
+                                    vertex_geom.local_on(
+                                        self.half_edges()
+                                            .before(half_edge)
+                                            .unwrap()
+                                            .curve(),
+                                    )
+                                })
+                                .cloned();
+                            let vertex_geom_start = core
+                                .layers
+                                .geometry
+                                .of_vertex(half_edge.start_vertex())
+                                .and_then(|vertex_geom| {
+                                    vertex_geom.local_on(half_edge.curve())
+                                })
+                                .cloned();
+                            let vertex_geom_end = core
+                                .layers
+                                .geometry
+                                .of_vertex(half_edge_next.start_vertex())
+                                .and_then(|vertex_geom| {
+                                    vertex_geom.local_on(half_edge.curve())
+                                })
+                                .cloned();
+                            if let Some(vertex_geom) = vertex_geom_prev_end {
+                                core.layers.geometry.define_vertex(
+                                    half_edge_other_next.start_vertex().clone(),
+                                    self.half_edges()
+                                        .before(half_edge)
+                                        .unwrap()
+                                        .curve()
+                                        .clone(),
+                                    vertex_geom,
+                                );
+                            }
+                            if let Some(vertex_geom_start) = vertex_geom_start {
+                                core.layers.geometry.define_vertex(
+                                    half_edge_other_next.start_vertex().clone(),
+                                    half_edge_other.curve().clone(),
+                                    vertex_geom_start,
+                                );
+                            }
+                            if let Some(vertex_geom_end) = vertex_geom_end {
+                                core.layers.geometry.define_vertex(
+                                    half_edge_other.start_vertex().clone(),
+                                    half_edge_other.curve().clone(),
+                                    vertex_geom_end,
+                                );
+                            }
+
                             [half_edge
                                 .update_curve(
-                                    |_, _| edge_other.curve().clone(),
+                                    |_, _| half_edge_other.curve().clone(),
                                     core,
                                 )
                                 .update_start_vertex(
                                     |_, _| {
-                                        other
-                                            .half_edges()
-                                            .nth_circular(index_other + 1)
+                                        half_edge_other_next
                                             .start_vertex()
                                             .clone()
                                     },
                                     core,
                                 )
-                                .insert(core)
-                                .set_path(
-                                    core.layers
-                                        .geometry
-                                        .of_half_edge(half_edge)
-                                        .path,
-                                    &mut core.layers.geometry,
-                                )]
+                                .insert(core)]
                         },
                         core,
                     )
                     .update_half_edge(
-                        self.half_edges().nth_circular(index + 1),
+                        half_edge_next,
                         |half_edge, core| {
+                            // And we need to move over the geometry for this
+                            // vertex too.
+                            let vertex_geom = core
+                                .layers
+                                .geometry
+                                .of_vertex(half_edge_next.start_vertex())
+                                .and_then(|vertex_geom| {
+                                    vertex_geom.local_on(half_edge_next.curve())
+                                })
+                                .cloned();
+                            if let Some(vertex_geom) = vertex_geom {
+                                core.layers.geometry.define_vertex(
+                                    half_edge_other.start_vertex().clone(),
+                                    half_edge.curve().clone(),
+                                    vertex_geom,
+                                );
+                            }
+
                             [half_edge
                                 .update_start_vertex(
-                                    |_, _| edge_other.start_vertex().clone(),
+                                    |_, _| {
+                                        half_edge_other.start_vertex().clone()
+                                    },
                                     core,
                                 )
-                                .insert(core)
-                                .set_path(
-                                    core.layers
-                                        .geometry
-                                        .of_half_edge(half_edge)
-                                        .path,
-                                    &mut core.layers.geometry,
-                                )]
+                                .insert(core)]
                         },
                         core,
                     )

crates/fj-core/src/operations/merge.rs

@@ -3,7 +3,7 @@
 //! See [`Merge`], which is currently the only trait in this module, for more
 //! information.
 
-use crate::{objects::Solid, Core};
+use crate::{Core, topology::Solid};
 
 use super::update::UpdateSolid;
 

crates/fj-core/src/operations/presentation.rs

@@ -2,7 +2,7 @@
 
 use fj_interop::Color;
 
-use crate::{objects::Region, storage::Handle, Core};
+use crate::{Core, storage::Handle, topology::Region};
 
 /// Get the color of an object
 pub trait GetColor {

crates/fj-core/src/operations/replace/curve.rs

@@ -1,12 +1,12 @@
 use std::ops::Deref;
 
 use crate::{
-    objects::{
-        Curve, Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid,
-    },
+    Core,
     operations::{derive::DeriveFrom, insert::Insert, update::UpdateHalfEdge},
     storage::Handle,
-    Core,
+    topology::{
+        Curve, Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid,
+    },
 };
 
 use super::ReplaceOutput;
@@ -151,7 +151,7 @@ impl ReplaceCurve for Sketch {
         }
 
         if replacement_happened {
-            ReplaceOutput::Updated(Sketch::new(regions))
+            ReplaceOutput::Updated(Sketch::new(self.surface().clone(), regions))
         } else {
             ReplaceOutput::Original(self.clone())
         }

crates/fj-core/src/operations/replace/half_edge.rs

@@ -1,10 +1,10 @@
 use std::ops::Deref;
 
 use crate::{
-    objects::{Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid},
+    Core,
     operations::{derive::DeriveFrom, insert::Insert},
     storage::Handle,
-    Core,
+    topology::{Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid},
 };
 
 use super::ReplaceOutput;
@@ -117,7 +117,7 @@ impl ReplaceHalfEdge for Sketch {
         }
 
         if replacement_happened {
-            ReplaceOutput::Updated(Sketch::new(regions))
+            ReplaceOutput::Updated(Sketch::new(self.surface().clone(), regions))
         } else {
             ReplaceOutput::Original(self.clone())
         }

crates/fj-core/src/operations/replace/vertex.rs

@@ -1,12 +1,12 @@
 use std::ops::Deref;
 
 use crate::{
-    objects::{
-        Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid, Vertex,
-    },
+    Core,
     operations::{derive::DeriveFrom, insert::Insert, update::UpdateHalfEdge},
     storage::Handle,
-    Core,
+    topology::{
+        Cycle, Face, HalfEdge, IsObject, Region, Shell, Sketch, Solid, Vertex,
+    },
 };
 
 use super::ReplaceOutput;
@@ -153,7 +153,7 @@ impl ReplaceVertex for Sketch {
         }
 
         if replacement_happened {
-            ReplaceOutput::Updated(Sketch::new(regions))
+            ReplaceOutput::Updated(Sketch::new(self.surface().clone(), regions))
         } else {
             ReplaceOutput::Original(self.clone())
         }
@@ -317,7 +317,7 @@ impl ReplaceVertex for Handle<Sketch> {
         }
 
         if replacement_happened {
-            ReplaceOutput::Updated(Sketch::new(regions))
+            ReplaceOutput::Updated(Sketch::new(self.surface().clone(), regions))
         } else {
             ReplaceOutput::Original(self.clone())
         }

crates/fj-core/src/operations/reverse/curve.rs

@@ -0,0 +1,54 @@
+use crate::{
+    Core,
+    operations::{derive::DeriveFrom, insert::Insert},
+    storage::Handle,
+    topology::{Curve, Surface},
+};
+
+use super::ReverseCurveCoordinateSystems;
+
+impl ReverseCurveCoordinateSystems for (&Handle<Curve>, &Handle<Surface>) {
+    type Reversed = Handle<Curve>;
+
+    fn reverse_curve_coordinate_systems(
+        self,
+        core: &mut Core,
+    ) -> Self::Reversed {
+        // We don't *actually* need a surface here, because *all* local
+        // definitions need to be reversed in sync anyway. However, then this
+        // method couldn't be called in `HalfEdge`'s implementation, meaning the
+        // way this trait works had to change completely.
+        //
+        // At this point it's probably not worth it to re-architect the trait,
+        // since eventually, redundant geometry definitions shouldn't exist any
+        // more, and then the existence of this trait, at least in its current
+        // form, is in question anyway.
+        //
+        // Once the dust has settled, we can figure out what needs to happen
+        // here. In the meantime, we can have this weird implementation, and
+        // rely on the callers to make sure everything stays consistent.
+        //
+        // [1]: https://github.com/hannobraun/fornjot/issues/2290
+        let (curve, surface) = self;
+
+        let mut curve_geom = core
+            .layers
+            .geometry
+            .of_curve(curve)
+            .unwrap()
+            .local_on(surface)
+            .unwrap()
+            .clone();
+        curve_geom.path = curve_geom.path.reverse();
+
+        let curve = Curve::new().insert(core).derive_from(curve, core);
+
+        core.layers.geometry.define_curve(
+            curve.clone(),
+            surface.clone(),
+            curve_geom,
+        );
+
+        curve
+    }
+}

crates/fj-core/src/operations/reverse/cycle.rs

@@ -1,11 +1,10 @@
 use crate::{
-    geometry::HalfEdgeGeometry,
-    objects::{Cycle, HalfEdge},
-    operations::{derive::DeriveFrom, insert::Insert},
     Core,
+    operations::{derive::DeriveFrom, insert::Insert},
+    topology::{Cycle, HalfEdge},
 };
 
-use super::{Reverse, ReverseCurveCoordinateSystems};
+use super::Reverse;
 
 impl Reverse for Cycle {
     fn reverse(&self, core: &mut Core) -> Self {
@@ -13,23 +12,12 @@ impl Reverse for Cycle {
             .half_edges()
             .pairs()
             .map(|(current, next)| {
-                let half_edge = HalfEdge::new(
-                    core.layers.geometry.of_half_edge(current).path,
-                    current.boundary().reverse(),
+                HalfEdge::new(
                     current.curve().clone(),
                     next.start_vertex().clone(),
                 )
                 .insert(core)
-                .derive_from(current, core);
-
-                core.layers.geometry.define_half_edge(
-                    half_edge.clone(),
-                    HalfEdgeGeometry {
-                        path: core.layers.geometry.of_half_edge(current).path,
-                    },
-                );
-
-                half_edge
+                .derive_from(current, core)
             })
             .collect::<Vec<_>>();
 
@@ -38,14 +26,3 @@ impl Reverse for Cycle {
         Cycle::new(edges)
     }
 }
-
-impl ReverseCurveCoordinateSystems for Cycle {
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let edges = self
-            .half_edges()
-            .iter()
-            .map(|edge| edge.reverse_curve_coordinate_systems(core));
-
-        Cycle::new(edges)
-    }
-}

crates/fj-core/src/operations/reverse/edge.rs

@@ -1,31 +0,0 @@
-use crate::{
-    geometry::HalfEdgeGeometry,
-    objects::HalfEdge,
-    operations::{derive::DeriveFrom, insert::Insert},
-    storage::Handle,
-    Core,
-};
-
-use super::ReverseCurveCoordinateSystems;
-
-impl ReverseCurveCoordinateSystems for Handle<HalfEdge> {
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let path = core.layers.geometry.of_half_edge(self).path.reverse();
-        let boundary = self.boundary().reverse();
-
-        let half_edge = HalfEdge::new(
-            path,
-            boundary,
-            self.curve().clone(),
-            self.start_vertex().clone(),
-        )
-        .insert(core)
-        .derive_from(self, core);
-
-        core.layers
-            .geometry
-            .define_half_edge(half_edge.clone(), HalfEdgeGeometry { path });
-
-        half_edge
-    }
-}

crates/fj-core/src/operations/reverse/face.rs

@@ -1,16 +1,16 @@
 use std::borrow::Borrow;
 
 use crate::{
-    objects::Face,
+    Core,
     operations::{
         build::Polygon,
         derive::DeriveFrom,
         insert::{Insert, IsInsertedNo, IsInsertedYes},
     },
-    Core,
+    topology::Face,
 };
 
-use super::{Reverse, ReverseCurveCoordinateSystems};
+use super::Reverse;
 
 impl Reverse for Face {
     fn reverse(&self, core: &mut Core) -> Self {
@@ -41,37 +41,3 @@ impl<const D: usize> Reverse for Polygon<D, IsInsertedYes> {
         self.replace_face(face)
     }
 }
-
-impl ReverseCurveCoordinateSystems for Face {
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let region = self
-            .region()
-            .reverse_curve_coordinate_systems(core)
-            .insert(core)
-            .derive_from(self.region(), core);
-        Face::new(self.surface().clone(), region)
-    }
-}
-
-impl<const D: usize> ReverseCurveCoordinateSystems
-    for Polygon<D, IsInsertedNo>
-{
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let face = self.face.borrow().reverse_curve_coordinate_systems(core);
-        self.replace_face(face)
-    }
-}
-
-impl<const D: usize> ReverseCurveCoordinateSystems
-    for Polygon<D, IsInsertedYes>
-{
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let face: &Face = self.face.borrow();
-        let face = face
-            .reverse_curve_coordinate_systems(core)
-            .insert(core)
-            .derive_from(&self.face, core);
-
-        self.replace_face(face)
-    }
-}

crates/fj-core/src/operations/reverse/half_edge.rs

@@ -0,0 +1,58 @@
+use crate::{
+    Core,
+    operations::{derive::DeriveFrom, insert::Insert},
+    storage::Handle,
+    topology::{HalfEdge, Surface, Vertex},
+};
+
+use super::ReverseCurveCoordinateSystems;
+
+impl ReverseCurveCoordinateSystems
+    for (&Handle<HalfEdge>, &Handle<Vertex>, &Handle<Surface>)
+{
+    type Reversed = Handle<HalfEdge>;
+
+    fn reverse_curve_coordinate_systems(
+        self,
+        core: &mut Core,
+    ) -> Self::Reversed {
+        let (half_edge, end_vertex, surface) = self;
+
+        let vertex_geom_start = core
+            .layers
+            .geometry
+            .of_vertex(half_edge.start_vertex())
+            .unwrap()
+            .local_on(half_edge.curve())
+            .unwrap()
+            .clone();
+        let vertex_geom_end = core
+            .layers
+            .geometry
+            .of_vertex(end_vertex)
+            .unwrap()
+            .local_on(half_edge.curve())
+            .unwrap()
+            .clone();
+
+        let curve =
+            (half_edge.curve(), surface).reverse_curve_coordinate_systems(core);
+
+        let half_edge = HalfEdge::new(curve, half_edge.start_vertex().clone())
+            .insert(core)
+            .derive_from(half_edge, core);
+
+        core.layers.geometry.define_vertex(
+            half_edge.start_vertex().clone(),
+            half_edge.curve().clone(),
+            vertex_geom_end,
+        );
+        core.layers.geometry.define_vertex(
+            end_vertex.clone(),
+            half_edge.curve().clone(),
+            vertex_geom_start,
+        );
+
+        half_edge
+    }
+}

crates/fj-core/src/operations/reverse/mod.rs

@@ -2,9 +2,10 @@
 
 use crate::Core;
 
+mod curve;
 mod cycle;
-mod edge;
 mod face;
+mod half_edge;
 mod region;
 
 /// Reverse the direction/orientation of an object
@@ -16,9 +17,15 @@ pub trait Reverse {
 
 /// Reverse the direction of the curve coordinate systems within an object
 pub trait ReverseCurveCoordinateSystems {
+    /// The type of the reversed object
+    type Reversed;
+
     /// Reverse the direction of the curve coordinate systems within an object
     ///
     /// This will not have any effect on object positions in global coordinates.
     #[must_use]
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self;
+    fn reverse_curve_coordinate_systems(
+        self,
+        core: &mut Core,
+    ) -> Self::Reversed;
 }

crates/fj-core/src/operations/reverse/region.rs

@@ -1,10 +1,10 @@
 use crate::{
-    objects::Region,
-    operations::{derive::DeriveFrom, insert::Insert},
     Core,
+    operations::{derive::DeriveFrom, insert::Insert},
+    topology::Region,
 };
 
-use super::{Reverse, ReverseCurveCoordinateSystems};
+use super::Reverse;
 
 impl Reverse for Region {
     fn reverse(&self, core: &mut Core) -> Self {
@@ -20,21 +20,3 @@ impl Reverse for Region {
         Region::new(exterior, interiors)
     }
 }
-
-impl ReverseCurveCoordinateSystems for Region {
-    fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self {
-        let exterior = self
-            .exterior()
-            .reverse_curve_coordinate_systems(core)
-            .insert(core)
-            .derive_from(self.exterior(), core);
-        let interiors = self.interiors().iter().map(|cycle| {
-            cycle
-                .reverse_curve_coordinate_systems(core)
-                .insert(core)
-                .derive_from(cycle, core)
-        });
-
-        Region::new(exterior, interiors)
-    }
-}

crates/fj-core/src/operations/split/edge.rs

@@ -1,14 +1,14 @@
 use fj_math::Point;
 
 use crate::{
-    objects::{HalfEdge, Shell},
-    operations::{
-        derive::DeriveFrom, geometry::UpdateHalfEdgeGeometry, insert::Insert,
-        replace::ReplaceHalfEdge, split::SplitHalfEdge, update::UpdateHalfEdge,
-    },
-    queries::SiblingOfHalfEdge,
-    storage::Handle,
     Core,
+    operations::{
+        insert::Insert, replace::ReplaceHalfEdge, split::SplitHalfEdge,
+        update::UpdateHalfEdge,
+    },
+    queries::{CycleOfHalfEdge, SiblingOfHalfEdge},
+    storage::Handle,
+    topology::{HalfEdge, Shell},
 };
 
 /// Split a pair of [`HalfEdge`]s into two
@@ -40,35 +40,23 @@ impl SplitEdge for Shell {
             .get_sibling_of(half_edge)
             .expect("Expected half-edge and its sibling to be part of shell");
 
-        let [half_edge_a, half_edge_b] = half_edge
-            .split_half_edge(point, core)
-            .map(|half_edge_part| {
-                half_edge_part.insert(core).derive_from(half_edge, core)
-            });
+        let [half_edge_a, half_edge_b] = self
+            .find_cycle_of_half_edge(half_edge)
+            .expect("Expected half-edge to be part of shell")
+            .split_half_edge(half_edge, point, core);
 
         let siblings = {
-            let [sibling_a, sibling_b] = sibling.split_half_edge(point, core);
+            let [sibling_a, sibling_b] =
+                sibling.cycle.split_half_edge(&sibling.sibling, point, core);
             let sibling_b = sibling_b
                 .update_start_vertex(
                     |_, _| half_edge_b.start_vertex().clone(),
                     core,
                 )
                 .insert(core);
-            [sibling_a, sibling_b].map(|half_edge| {
-                half_edge.insert(core).derive_from(&sibling, core).set_path(
-                    core.layers.geometry.of_half_edge(&sibling).path,
-                    &mut core.layers.geometry,
-                )
-            })
-        };
 
-        let [half_edge_a, half_edge_b] =
-            [half_edge_a, half_edge_b].map(|half_edge_part| {
-                half_edge_part.set_path(
-                    core.layers.geometry.of_half_edge(half_edge).path,
-                    &mut core.layers.geometry,
-                )
-            });
+            [sibling_a, sibling_b]
+        };
 
         let shell = self
             .replace_half_edge(
@@ -77,7 +65,7 @@ impl SplitEdge for Shell {
                 core,
             )
             .into_inner()
-            .replace_half_edge(&sibling, siblings.clone(), core)
+            .replace_half_edge(&sibling.sibling, siblings.clone(), core)
             .into_inner();
 
         (shell, [[half_edge_a, half_edge_b], siblings])

crates/fj-core/src/operations/split/face.rs

@@ -1,13 +1,12 @@
-use fj_interop::ext::ArrayExt;
 use fj_math::Point;
 use itertools::Itertools;
 
 use crate::{
-    objects::{Cycle, Face, HalfEdge, Shell},
+    Core,
+    geometry::LocalVertexGeom,
     operations::{
         build::{BuildCycle, BuildHalfEdge},
         derive::DeriveFrom,
-        geometry::UpdateHalfEdgeGeometry,
         insert::Insert,
         split::SplitEdge,
         update::{
@@ -15,7 +14,7 @@ use crate::{
         },
     },
     storage::Handle,
-    Core,
+    topology::{Cycle, Face, HalfEdge, Shell},
 };
 
 /// Split a face into two
@@ -63,7 +62,7 @@ impl SplitFace for Shell {
         //
         // Something to think about though!
         {
-            let [(a, _), (b, _)] = line.each_ref_ext();
+            let [(a, _), (b, _)] = line.each_ref();
 
             let exterior = face.region().exterior();
 
@@ -103,18 +102,65 @@ impl SplitFace for Shell {
 
         // Build the edge that's going to divide the new faces.
         let dividing_half_edge_a_to_d = {
-            let half_edge = HalfEdge::line_segment(
-                [b.start_position(), d.start_position()],
-                None,
+            let start = core
+                .layers
+                .geometry
+                .of_curve(b.curve())
+                .unwrap()
+                .local_on(face.surface())
+                .unwrap()
+                .path
+                .point_from_path_coords(
+                    core.layers
+                        .geometry
+                        .of_vertex(b.start_vertex())
+                        .unwrap()
+                        .local_on(b.curve())
+                        .unwrap()
+                        .position,
+                );
+            let end = core
+                .layers
+                .geometry
+                .of_curve(d.curve())
+                .unwrap()
+                .local_on(face.surface())
+                .unwrap()
+                .path
+                .point_from_path_coords(
+                    core.layers
+                        .geometry
+                        .of_vertex(d.start_vertex())
+                        .unwrap()
+                        .local_on(d.curve())
+                        .unwrap()
+                        .position,
+                );
+
+            let (half_edge, boundary) = HalfEdge::line_segment(
+                [start, end],
+                face.surface().clone(),
                 core,
             );
+
+            core.layers.geometry.define_vertex(
+                b.start_vertex().clone(),
+                half_edge.curve().clone(),
+                LocalVertexGeom {
+                    position: boundary.inner[0],
+                },
+            );
+            core.layers.geometry.define_vertex(
+                d.start_vertex().clone(),
+                half_edge.curve().clone(),
+                LocalVertexGeom {
+                    position: boundary.inner[1],
+                },
+            );
+
             half_edge
                 .update_start_vertex(|_, _| b.start_vertex().clone(), core)
                 .insert(core)
-                .set_path(
-                    core.layers.geometry.of_half_edge(&half_edge).path,
-                    &mut core.layers.geometry,
-                )
         };
         let dividing_half_edge_c_to_b = HalfEdge::from_sibling(
             &dividing_half_edge_a_to_d,
@@ -201,13 +247,13 @@ mod tests {
     use fj_interop::Color;
 
     use crate::{
-        objects::Shell,
+        Core,
         operations::{
             build::BuildShell,
             presentation::{GetColor, SetColor},
             split::SplitFace,
         },
-        Core,
+        topology::Shell,
     };
 
     #[test]

crates/fj-core/src/operations/split/half_edge.rs

@@ -1,11 +1,11 @@
 use fj_math::Point;
 
 use crate::{
-    geometry::HalfEdgeGeometry,
-    objects::{HalfEdge, Vertex},
-    operations::insert::Insert,
-    storage::Handle,
     Core,
+    geometry::LocalVertexGeom,
+    operations::{derive::DeriveFrom, insert::Insert},
+    storage::Handle,
+    topology::{Cycle, HalfEdge, Vertex},
 };
 
 /// Split a [`HalfEdge`] into two
@@ -28,47 +28,38 @@ pub trait SplitHalfEdge {
     #[must_use]
     fn split_half_edge(
         &self,
+        half_edge: &Handle<HalfEdge>,
         point: impl Into<Point<1>>,
         core: &mut Core,
     ) -> [Handle<HalfEdge>; 2];
 }
 
-impl SplitHalfEdge for Handle<HalfEdge> {
+impl SplitHalfEdge for Cycle {
     fn split_half_edge(
         &self,
+        half_edge: &Handle<HalfEdge>,
         point: impl Into<Point<1>>,
         core: &mut Core,
     ) -> [Handle<HalfEdge>; 2] {
         let point = point.into();
 
-        let [start, end] = self.boundary().inner;
-
         let a = HalfEdge::new(
-            core.layers.geometry.of_half_edge(self).path,
-            [start, point],
-            self.curve().clone(),
-            self.start_vertex().clone(),
+            half_edge.curve().clone(),
+            half_edge.start_vertex().clone(),
         )
-        .insert(core);
+        .insert(core)
+        .derive_from(half_edge, core);
         let b = HalfEdge::new(
-            core.layers.geometry.of_half_edge(self).path,
-            [point, end],
-            self.curve().clone(),
+            half_edge.curve().clone(),
             Vertex::new().insert(core),
         )
-        .insert(core);
+        .insert(core)
+        .derive_from(half_edge, core);
 
-        core.layers.geometry.define_half_edge(
-            a.clone(),
-            HalfEdgeGeometry {
-                path: core.layers.geometry.of_half_edge(self).path,
-            },
-        );
-        core.layers.geometry.define_half_edge(
-            b.clone(),
-            HalfEdgeGeometry {
-                path: core.layers.geometry.of_half_edge(self).path,
-            },
+        core.layers.geometry.define_vertex(
+            b.start_vertex().clone(),
+            b.curve().clone(),
+            LocalVertexGeom { position: point },
         );
 
         [a, b]

crates/fj-core/src/operations/sweep/cycle.rs

@@ -1,13 +1,15 @@
 use fj_interop::Color;
 use fj_math::Vector;
+use itertools::Itertools;
 
 use crate::{
-    geometry::SurfaceGeometry,
-    objects::{Cycle, Face},
+    Core,
+    geometry::LocalVertexGeom,
     operations::{
         build::BuildCycle, join::JoinCycle, sweep::half_edge::SweepHalfEdge,
     },
-    Core,
+    storage::Handle,
+    topology::{Cycle, Face, Surface},
 };
 
 use super::SweepCache;
@@ -38,7 +40,8 @@ pub trait SweepCycle {
     /// operation is called in, and therefore falls outside of its scope.
     fn sweep_cycle(
         &self,
-        surface: &SurfaceGeometry,
+        bottom_surface: Handle<Surface>,
+        top_surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
@@ -49,7 +52,8 @@ pub trait SweepCycle {
 impl SweepCycle for Cycle {
     fn sweep_cycle(
         &self,
-        surface: &SurfaceGeometry,
+        bottom_surface: Handle<Surface>,
+        top_surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
@@ -58,31 +62,89 @@ impl SweepCycle for Cycle {
         let path = path.into();
 
         let mut faces = Vec::new();
-        let mut top_edges = Vec::new();
+        let mut top_half_edges = Vec::new();
 
         for bottom_half_edge_pair in self.half_edges().pairs() {
             let (bottom_half_edge, bottom_half_edge_next) =
                 bottom_half_edge_pair;
 
-            let (side_face, top_edge) = bottom_half_edge.sweep_half_edge(
+            let swept_half_edge = bottom_half_edge.sweep_half_edge(
                 bottom_half_edge_next.start_vertex().clone(),
-                surface,
+                bottom_surface.clone(),
                 color,
                 path,
                 cache,
                 core,
             );
 
-            faces.push(side_face);
+            faces.push(swept_half_edge.face);
 
-            top_edges.push((
-                top_edge,
-                core.layers.geometry.of_half_edge(bottom_half_edge).path,
-                bottom_half_edge.boundary(),
+            // The order of these top half-edges is going to be important later,
+            // so let's make sure we understand what's going on:
+            //
+            // - We are iterating through the bottom half-edges here. That means
+            //   the order of those bottom half-edges is natural, as we'd expect
+            //   it:
+            //   - We see them in the order that they appear in the cycle.
+            //   - Each half-edge we see ends where the next one starts.
+            // - By sweeping the bottom half-edges, we are creating a top half-
+            //   edges that have opposite orientation.
+            // - And yet we're adding them to a list, in the same order that we
+            //   iterate over the bottom half-edges.
+            // - As a result, the order of the list is unnatural, going against
+            //   expectations:
+            //   - This is the opposite order than the one in which they'll
+            //     appear within a cycle eventually.
+            //   - Each half-edge ends where the _previous_ one (in the list)
+            //     starts.
+            top_half_edges.push((
+                swept_half_edge.top_half_edge,
+                swept_half_edge.top_boundary,
+                core.layers
+                    .geometry
+                    .of_curve(bottom_half_edge.curve())
+                    .unwrap()
+                    .local_on(&bottom_surface)
+                    .unwrap()
+                    .clone(),
             ));
         }
 
-        let top_cycle = Cycle::empty().add_joined_edges(top_edges, core);
+        let top_half_edges = top_half_edges
+            .into_iter()
+            .circular_tuple_windows()
+            .map(
+                |(
+                    (half_edge, boundary, curve_geom),
+                    (next_half_edge, _, _),
+                )| {
+                    let [start, end] = boundary.inner;
+
+                    for (point, vertex) in [
+                        (start, half_edge.start_vertex()),
+                        (end, next_half_edge.start_vertex()),
+                    ] {
+                        core.layers.geometry.define_vertex(
+                            vertex.clone(),
+                            half_edge.curve().clone(),
+                            LocalVertexGeom { position: point },
+                        );
+                    }
+
+                    (half_edge, curve_geom)
+                },
+            )
+            .collect::<Vec<_>>();
+
+        // The half-edges within `top_half_edges` which we're passing into
+        // `add_joined_edges` are in unnatural order, as per the comment above.
+        // This happens to be exactly the order that `add_joined_edges` wants
+        // them to be in, so it works out.
+        let top_cycle = Cycle::empty().add_joined_half_edges(
+            top_half_edges,
+            top_surface,
+            core,
+        );
 
         SweptCycle { faces, top_cycle }
     }

crates/fj-core/src/operations/sweep/face.rs

@@ -1,10 +1,10 @@
 use fj_math::Vector;
 
 use crate::{
-    objects::{Face, Shell},
+    Core,
     operations::{insert::Insert, presentation::GetColor},
     storage::Handle,
-    Core,
+    topology::{Face, Shell},
 };
 
 use super::{SweepCache, SweepRegion};
@@ -50,14 +50,14 @@ impl SweepFace for Handle<Face> {
         let other_faces = bottom_face
             .region()
             .sweep_region(
-                bottom_face.surface(),
+                bottom_face.surface().clone(),
                 bottom_face.region().get_color(core),
                 path,
                 cache,
                 core,
             )
             .all_faces()
-            .map(|side_face| side_face.insert(core));
+            .map(|face| face.insert(core));
 
         let mut faces = Vec::new();
         faces.push(bottom_face.clone());

crates/fj-core/src/operations/sweep/half_edge.rs

@@ -1,21 +1,21 @@
-use fj_interop::{ext::ArrayExt, Color};
+use fj_interop::{Color, ext::ArrayExt};
 use fj_math::{Point, Scalar, Vector};
 
 use crate::{
-    geometry::SurfaceGeometry,
-    objects::{Cycle, Face, HalfEdge, Region, Vertex},
+    Core,
+    geometry::{CurveBoundary, LocalVertexGeom},
     operations::{
         build::{BuildCycle, BuildHalfEdge},
-        geometry::UpdateHalfEdgeGeometry,
+        geometry::UpdateCurveGeometry,
         insert::Insert,
         presentation::SetColor,
         update::{UpdateCycle, UpdateHalfEdge},
     },
     storage::Handle,
-    Core,
+    topology::{Curve, Cycle, Face, HalfEdge, Region, Surface, Vertex},
 };
 
-use super::{vertex::SweepVertex, SweepCache, SweepSurfacePath};
+use super::{SweepCache, SweepSurfacePath, vertex::SweepVertex};
 
 /// # Sweep a [`HalfEdge`]
 ///
@@ -39,32 +39,55 @@ pub trait SweepHalfEdge {
     fn sweep_half_edge(
         &self,
         end_vertex: Handle<Vertex>,
-        surface: &SurfaceGeometry,
+        surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
         core: &mut Core,
-    ) -> (Face, Handle<HalfEdge>);
+    ) -> SweptHalfEdge;
 }
 
 impl SweepHalfEdge for Handle<HalfEdge> {
     fn sweep_half_edge(
         &self,
         end_vertex: Handle<Vertex>,
-        surface: &SurfaceGeometry,
+        surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
         core: &mut Core,
-    ) -> (Face, Handle<HalfEdge>) {
+    ) -> SweptHalfEdge {
         let path = path.into();
 
-        let surface = core
+        let boundary = [
+            core.layers
+                .geometry
+                .of_vertex(self.start_vertex())
+                .unwrap()
+                .local_on(self.curve())
+                .unwrap()
+                .position,
+            core.layers
+                .geometry
+                .of_vertex(&end_vertex)
+                .unwrap()
+                .local_on(self.curve())
+                .unwrap()
+                .position,
+        ];
+        let curve_geom = core
             .layers
             .geometry
-            .of_half_edge(self)
+            .of_curve(self.curve())
+            .unwrap()
+            .local_on(&surface)
+            .unwrap()
+            .clone();
+        let surface_geom = *core.layers.geometry.of_surface(&surface);
+        let surface =
+            curve_geom
                 .path
-            .sweep_surface_path(surface, path, core);
+                .sweep_surface_path(&surface_geom, path, core);
 
         // Next, we need to define the boundaries of the face. Let's start with
         // the global vertices and edges.
@@ -86,7 +109,7 @@ impl SweepHalfEdge for Handle<HalfEdge> {
 
         // Let's figure out the surface coordinates of the edge vertices.
         let surface_points = {
-            let [a, b] = self.boundary().inner;
+            let [a, b] = boundary;
 
             [
                 [a.t, Scalar::ZERO],
@@ -104,46 +127,71 @@ impl SweepHalfEdge for Handle<HalfEdge> {
 
         // Now, the boundaries of each edge.
         let boundaries = {
-            let [a, b] = self.boundary().inner;
+            let [a, b] = boundary;
             let [c, d] = [0., 1.].map(|coord| Point::from([coord]));
 
             [[a, b], [c, d], [b, a], [d, c]]
         };
 
+        let vertices_pairs = {
+            let [a, b, c, d] = vertices;
+            [
+                [a.clone(), b.clone()],
+                [b, c.clone()],
+                [c, d.clone()],
+                [d, a],
+            ]
+        };
+
         let mut exterior = Cycle::empty();
 
         // Armed with all of that, we're ready to create the edges.
         let [_edge_bottom, _edge_up, edge_top, _edge_down] = boundaries
             .zip_ext(surface_points)
             .zip_ext(surface_points_next)
-            .zip_ext(vertices)
+            .zip_ext(vertices_pairs)
             .zip_ext(curves)
-            .map(|((((boundary, start), end), start_vertex), curve)| {
-                let half_edge = {
-                    let line_segment = HalfEdge::line_segment(
+            .map(
+                |(
+                    (((boundary, start), end), [start_vertex, end_vertex]),
+                    curve,
+                )| {
+                    let boundary = CurveBoundary { inner: boundary };
+
+                    let curve = curve
+                        .unwrap_or_else(|| Curve::new().insert(core))
+                        .make_line_on_surface(
                             [start, end],
-                        Some(boundary),
-                        core,
-                    );
-                    let half_edge = line_segment
-                        .update_start_vertex(|_, _| start_vertex, core);
-
-                    let half_edge = if let Some(curve) = curve {
-                        half_edge.update_curve(|_, _| curve, core)
-                    } else {
-                        half_edge
-                    };
-
-                    half_edge.insert(core).set_path(
-                        core.layers.geometry.of_half_edge(&line_segment).path,
+                            boundary,
+                            surface.clone(),
                             &mut core.layers.geometry,
-                    )
-                };
+                        );
 
-                exterior = exterior.add_half_edges([half_edge.clone()], core);
+                    {
+                        let [start, end] = boundary.inner;
+
+                        for (point, vertex) in
+                            [(start, start_vertex.clone()), (end, end_vertex)]
+                        {
+                            core.layers.geometry.define_vertex(
+                                vertex,
+                                curve.clone(),
+                                LocalVertexGeom { position: point },
+                            );
+                        }
+                    }
+
+                    let half_edge = HalfEdge::unjoined(core)
+                        .update_start_vertex(|_, _| start_vertex, core)
+                        .update_curve(|_, _| curve.clone(), core)
+                        .insert(core);
+
+                    exterior =
+                        exterior.add_half_edges([half_edge.clone()], core);
 
                     half_edge
-            });
+                },
+            );
 
         let exterior = exterior.insert(core);
         let region = Region::new(exterior, []).insert(core);
@@ -153,7 +201,28 @@ impl SweepHalfEdge for Handle<HalfEdge> {
         }
 
         let face = Face::new(surface, region);
+        let [_, _, top_boundary, _] = boundaries;
 
-        (face, edge_top)
+        SweptHalfEdge {
+            face,
+            top_half_edge: edge_top,
+            top_boundary: CurveBoundary {
+                inner: top_boundary,
+            },
+        }
     }
 }
+
+/// The result of sweeping a [`HalfEdge`]
+///
+/// See [`SweepHalfEdge`].
+pub struct SweptHalfEdge {
+    /// The face created by sweeping the half-edge
+    pub face: Face,
+
+    /// The top half-edge of the created face
+    pub top_half_edge: Handle<HalfEdge>,
+
+    /// The boundary of the top half-edge
+    pub top_boundary: CurveBoundary<Point<1>>,
+}

crates/fj-core/src/operations/sweep/mod.rs

@@ -15,7 +15,7 @@ mod vertex;
 pub use self::{
     cycle::{SweepCycle, SweptCycle},
     face::SweepFace,
-    half_edge::SweepHalfEdge,
+    half_edge::{SweepHalfEdge, SweptHalfEdge},
     path::SweepSurfacePath,
     region::{SweepRegion, SweptRegion},
     shell_face::{ShellExtendedBySweep, SweepFaceOfShell},
@@ -26,8 +26,8 @@ pub use self::{
 use std::collections::BTreeMap;
 
 use crate::{
-    objects::{Curve, Vertex},
     storage::{Handle, ObjectId},
+    topology::{Curve, Vertex},
 };
 
 /// A cache used for sweeping

crates/fj-core/src/operations/sweep/path.rs

@@ -1,14 +1,20 @@
 use fj_math::{Circle, Line, Vector};
 
 use crate::{
-    geometry::{GlobalPath, SurfaceGeometry, SurfacePath},
-    objects::Surface,
+    Core,
+    geometry::{
+        Path,
+        repr::tri_mesh::{
+            convert_point_surface_to_global, convert_vector_surface_to_global,
+        },
+        surfaces::SweptCurve,
+    },
     operations::build::BuildSurface,
     storage::Handle,
-    Core,
+    topology::Surface,
 };
 
-/// # Sweep a [`SurfacePath`]
+/// # Sweep a [`Path`]
 ///
 /// See [module documentation] for more information.
 ///
@@ -26,30 +32,31 @@ pub trait SweepSurfacePath {
     /// <https://github.com/hannobraun/fornjot/issues/1112>
     fn sweep_surface_path(
         &self,
-        surface: &SurfaceGeometry,
+        surface: &SweptCurve,
         path: impl Into<Vector<3>>,
         core: &mut Core,
     ) -> Handle<Surface>;
 }
 
-impl SweepSurfacePath for SurfacePath {
+impl SweepSurfacePath for Path<2> {
     fn sweep_surface_path(
         &self,
-        surface: &SurfaceGeometry,
+        surface: &SweptCurve,
         path: impl Into<Vector<3>>,
         core: &mut Core,
     ) -> Handle<Surface> {
-        match surface.u {
-            GlobalPath::Circle(_) => {
+        let SweptCurve { u, .. } = surface;
+        match u {
+            Path::Circle(_) => {
                 // Sweeping a `Curve` creates a `Surface`. The u-axis of that
-                // `Surface` is a `GlobalPath`, which we are computing below.
-                // That computation might or might not work with an arbitrary
+                // `Surface` is a `Path<3>`, which we are computing below. That
+                // computation might or might not work with an arbitrary
                 // surface. Probably not, but I'm not sure.
                 //
                 // What definitely won't work, is computing the bottom edge of
                 // the sweep. The edge sweeping code currently assumes that the
                 // bottom edge is a line (which is true when sweeping from a
-                // flat surface). But is the surface we're sweeping from is
+                // flat surface). But if the surface we're sweeping from is
                 // curved, there's simply no way to represent the curve of the
                 // resulting bottom edge.
                 todo!(
@@ -57,33 +64,57 @@ impl SweepSurfacePath for SurfacePath {
                     not supported yet."
                 )
             }
-            GlobalPath::Line(_) => {
+            Path::Line(_) => {
                 // We're sweeping from a curve on a flat surface, which is
                 // supported. Carry on.
             }
         }
 
         let u = match self {
-            SurfacePath::Circle(circle) => {
-                let center = surface.point_from_surface_coords(circle.center());
-                let a = surface.vector_from_surface_coords(circle.a());
-                let b = surface.vector_from_surface_coords(circle.b());
+            Path::Circle(circle) => {
+                let center = convert_point_surface_to_global(
+                    surface,
+                    circle.center(),
+                    core.tolerance(),
+                    &core.layers.geometry,
+                );
+                let a = convert_vector_surface_to_global(
+                    surface,
+                    circle.a(),
+                    core.tolerance(),
+                    &core.layers.geometry,
+                );
+                let b = convert_vector_surface_to_global(
+                    surface,
+                    circle.b(),
+                    core.tolerance(),
+                    &core.layers.geometry,
+                );
 
                 let circle = Circle::new(center, a, b);
 
-                GlobalPath::Circle(circle)
+                Path::Circle(circle)
             }
-            SurfacePath::Line(line) => {
-                let origin = surface.point_from_surface_coords(line.origin());
-                let direction =
-                    surface.vector_from_surface_coords(line.direction());
+            Path::Line(line) => {
+                let origin = convert_point_surface_to_global(
+                    surface,
+                    line.origin(),
+                    core.tolerance(),
+                    &core.layers.geometry,
+                );
+                let direction = convert_vector_surface_to_global(
+                    surface,
+                    line.direction(),
+                    core.tolerance(),
+                    &core.layers.geometry,
+                );
 
                 let line = Line::from_origin_and_direction(origin, direction);
 
-                GlobalPath::Line(line)
+                Path::Line(line)
             }
         };
 
-        Surface::surface_from_uv(u, path, core)
+        Surface::from_uv(u, path, core)
     }
 }

crates/fj-core/src/operations/sweep/region.rs

@@ -2,13 +2,12 @@ use fj_interop::Color;
 use fj_math::Vector;
 
 use crate::{
-    geometry::SurfaceGeometry,
-    objects::{Cycle, Face, Region, Surface},
+    Core,
     operations::{
         insert::Insert, reverse::Reverse, transform::TransformObject,
     },
     storage::Handle,
-    Core,
+    topology::{Cycle, Face, Region, Surface},
 };
 
 use super::{SweepCache, SweepCycle};
@@ -32,7 +31,7 @@ pub trait SweepRegion {
     /// operation's scope.
     fn sweep_region(
         &self,
-        surface: &Handle<Surface>,
+        bottom_surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
@@ -43,7 +42,7 @@ pub trait SweepRegion {
 impl SweepRegion for Region {
     fn sweep_region(
         &self,
-        surface: &Handle<Surface>,
+        bottom_surface: Handle<Surface>,
         color: Option<Color>,
         path: impl Into<Vector<3>>,
         cache: &mut SweepCache,
@@ -53,9 +52,13 @@ impl SweepRegion for Region {
 
         let mut faces = Vec::new();
 
+        let top_surface =
+            bottom_surface.clone().translate(path, core).insert(core);
+
         let top_exterior = sweep_cycle(
             self.exterior(),
-            &core.layers.geometry.of_surface(surface),
+            bottom_surface.clone(),
+            top_surface.clone(),
             color,
             &mut faces,
             path,
@@ -69,7 +72,8 @@ impl SweepRegion for Region {
             .map(|bottom_cycle| {
                 sweep_cycle(
                     bottom_cycle,
-                    &core.layers.geometry.of_surface(surface),
+                    bottom_surface.clone(),
+                    top_surface.clone(),
                     color,
                     &mut faces,
                     path,
@@ -80,7 +84,6 @@ impl SweepRegion for Region {
             .collect::<Vec<_>>();
 
         let top_face = {
-            let top_surface = surface.translate(path, core).insert(core);
             let top_region =
                 Region::new(top_exterior, top_interiors).insert(core);
 
@@ -94,9 +97,11 @@ impl SweepRegion for Region {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn sweep_cycle(
     bottom_cycle: &Cycle,
-    bottom_surface: &SurfaceGeometry,
+    bottom_surface: Handle<Surface>,
+    top_surface: Handle<Surface>,
     color: Option<Color>,
     faces: &mut Vec<Face>,
     path: Vector<3>,
@@ -105,6 +110,7 @@ fn sweep_cycle(
 ) -> Handle<Cycle> {
     let swept_cycle = bottom_cycle.reverse(core).sweep_cycle(
         bottom_surface,
+        top_surface,
         color,
         path,
         cache,

crates/fj-core/src/operations/sweep/shell_face.rs

@@ -1,7 +1,7 @@
 use fj_math::Vector;
 
 use crate::{
-    objects::{Face, Region, Shell},
+    Core,
     operations::{
         derive::DeriveFrom,
         insert::Insert,
@@ -11,7 +11,7 @@ use crate::{
         update::UpdateShell,
     },
     storage::Handle,
-    Core,
+    topology::{Face, Region, Shell},
 };
 
 /// # Sweep a [`Face`] that is part of a [`Shell`]
@@ -66,7 +66,7 @@ impl SweepFaceOfShell for Shell {
             .derive_from(face.region().exterior(), core);
         let region = Region::new(exterior, []);
         let swept_region = region.sweep_region(
-            face.surface(),
+            face.surface().clone(),
             face.region().get_color(core),
             path,
             &mut cache,

crates/fj-core/src/operations/sweep/sketch.rs

@@ -1,14 +1,13 @@
-use fj_math::{Scalar, Vector};
+use fj_math::Vector;
 
 use crate::{
-    geometry::GlobalPath,
-    objects::{Face, Sketch, Solid, Surface},
-    operations::{derive::DeriveFrom, insert::Insert, reverse::Reverse},
-    storage::Handle,
     Core,
+    operations::insert::Insert,
+    storage::Handle,
+    topology::{Face, Sketch, Solid, Surface},
 };
 
-use super::{face::SweepFace, SweepCache};
+use super::{SweepCache, face::SweepFace};
 
 /// # Sweep a [`Sketch`]
 ///
@@ -17,6 +16,27 @@ use super::{face::SweepFace, SweepCache};
 /// [module documentation]: super
 pub trait SweepSketch {
     /// # Sweep the [`Sketch`]
+    ///
+    /// Requires `path` to point towards the back of `surface`. If one of them
+    /// is fixed, make sure to adapt the other one accordingly.
+    ///
+    /// Not following this requirement will produce an invalid shape that
+    /// _should_ fail validation.
+    ///
+    /// ## Implementation Note
+    ///
+    /// The above requirement is a bit draconian. It would be much nicer, if
+    /// this operation just worked, regardless of the relation of `path` and
+    /// `surface`, and in fact, a previous version of it did.
+    ///
+    /// However, this previous version also made some undocumented assumption
+    /// that didn't hold in the general case. It was also getting in the way of
+    /// introducing the new geometry system.
+    ///
+    /// The decision was made that, for now, simplifying this operation and
+    /// putting more requirements on the caller, was the right call. Once the
+    /// new geometry system is in place, we'll hopefully be in a position to
+    /// improve the sweep operation substantially.
     fn sweep_sketch(
         &self,
         surface: Handle<Surface>,
@@ -37,35 +57,23 @@ impl SweepSketch for Sketch {
 
         let mut shells = Vec::new();
         for region in self.regions() {
-            let region = {
-                // The following code assumes that the sketch is winded counter-
-                // clockwise. Let's check that real quick.
-                assert!(region
-                    .exterior()
-                    .winding(&core.layers.geometry)
-                    .is_ccw());
+            for cycle in region.all_cycles() {
+                for half_edge in cycle.half_edges() {
+                    let curve_geom = core
+                        .layers
+                        .geometry
+                        .of_curve(half_edge.curve())
+                        .unwrap()
+                        .local_on(self.surface())
+                        .unwrap();
 
-                let is_negative_sweep = {
-                    let u = match core.layers.geometry.of_surface(&surface).u {
-                        GlobalPath::Circle(_) => todo!(
-                            "Sweeping sketch from a rounded surfaces is not \
-                            supported"
-                        ),
-                        GlobalPath::Line(line) => line.direction(),
-                    };
-                    let v = core.layers.geometry.of_surface(&surface).v;
-
-                    let normal = u.cross(&v);
-
-                    normal.dot(&path) < Scalar::ZERO
-                };
-
-                if is_negative_sweep {
-                    region.clone()
-                } else {
-                    region.reverse(core).insert(core).derive_from(region, core)
+                    core.layers.geometry.define_curve(
+                        half_edge.curve().clone(),
+                        surface.clone(),
+                        curve_geom.clone(),
+                    );
+                }
             }
-            };
 
             let face = Face::new(surface.clone(), region.clone()).insert(core);
             let shell = face.sweep_face(path, &mut cache, core).insert(core);

crates/fj-core/src/operations/sweep/vertex.rs

@@ -1,8 +1,8 @@
 use crate::{
-    objects::{Curve, Vertex},
+    Core,
     operations::insert::Insert,
     storage::Handle,
-    Core,
+    topology::{Curve, Vertex},
 };
 
 use super::SweepCache;