Make use of Sketch and Solid in fj-operations

crates/fj-operations/src/difference_2d.rs

@@ -3,24 +3,26 @@ use fj_kernel::{
     algorithms::Tolerance,
     iter::ObjectIters,
     local::Local,
-    objects::{Cycle, Edge, Face},
+    objects::{Cycle, Edge, Face, Sketch},
     validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::Aabb;
 
 use super::Shape;
 
 impl Shape for fj::Difference2d {
+    type Brep = Sketch;
+
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError> {
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
         // This method assumes that `b` is fully contained within `a`:
         // https://github.com/hannobraun/Fornjot/issues/92
 
-        let mut difference = Vec::new();
+        let mut faces = Vec::new();
 
         let mut exteriors = Vec::new();
         let mut interiors = Vec::new();
@@ -72,14 +74,10 @@ impl Shape for fj::Difference2d {
                 }
             }
 
-            difference.push(Face::new(
-                surface,
-                exteriors,
-                interiors,
-                self.color(),
-            ));
+            faces.push(Face::new(surface, exteriors, interiors, self.color()));
         }
 
+        let difference = Sketch::from_faces(faces);
         validate(difference, config)
     }
 

crates/fj-operations/src/group.rs

@@ -1,29 +1,32 @@
 use fj_interop::debug::DebugInfo;
 use fj_kernel::{
     algorithms::Tolerance,
-    objects::Face,
+    objects::Solid,
     validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::Aabb;
 
 use super::Shape;
 
 impl Shape for fj::Group {
+    type Brep = Solid;
+
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError> {
-        let mut shape = Vec::new();
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
+        let mut faces = Vec::new();
 
         let a = self.a.compute_brep(config, tolerance, debug_info)?;
         let b = self.b.compute_brep(config, tolerance, debug_info)?;
 
-        shape.extend(a.into_inner());
-        shape.extend(b.into_inner());
+        faces.extend(a.into_inner().into_faces());
+        faces.extend(b.into_inner().into_faces());
 
-        validate(shape, config)
+        let group = Solid::from_faces(faces);
+        validate(group, config)
     }
 
     fn bounding_volume(&self) -> Aabb<3> {

crates/fj-operations/src/lib.rs

@@ -27,20 +27,23 @@ mod transform;
 use fj_interop::debug::DebugInfo;
 use fj_kernel::{
     algorithms::Tolerance,
-    objects::Face,
-    validation::{Validated, ValidationConfig, ValidationError},
+    objects::{Face, Sketch, Solid},
+    validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::Aabb;
 
 /// Implemented for all operations from the [`fj`] crate
 pub trait Shape {
+    /// The type that is used for the shape's boundary representation
+    type Brep;
+
     /// Compute the boundary representation of the shape
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError>;
+    ) -> Result<Validated<Self::Brep>, ValidationError>;
 
     /// Access the axis-aligned bounding box of a shape
     ///
@@ -49,49 +52,95 @@ pub trait Shape {
     fn bounding_volume(&self) -> Aabb<3>;
 }
 
-macro_rules! dispatch {
-    ($($method:ident($($arg_name:ident: $arg_ty:ty,)*) -> $ret:ty;)*) => {
-        impl Shape for fj::Shape {
-            $(
-                fn $method(&self, $($arg_name: $arg_ty,)*) -> $ret {
-                    match self {
-                        Self::Shape2d(shape) => shape.$method($($arg_name,)*),
-                        Self::Shape3d(shape) => shape.$method($($arg_name,)*),
-                    }
-                }
-            )*
+impl Shape for fj::Shape {
+    type Brep = Vec<Face>;
+
+    fn compute_brep(
+        &self,
+        config: &ValidationConfig,
+        tolerance: Tolerance,
+        debug_info: &mut DebugInfo,
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
+        match self {
+            Self::Shape2d(shape) => validate(
+                shape
+                    .compute_brep(config, tolerance, debug_info)?
+                    .into_inner()
+                    .into_faces(),
+                config,
+            ),
+            Self::Shape3d(shape) => validate(
+                shape
+                    .compute_brep(config, tolerance, debug_info)?
+                    .into_inner()
+                    .into_faces(),
+                config,
+            ),
+        }
+    }
+
+    fn bounding_volume(&self) -> Aabb<3> {
+        match self {
+            Self::Shape2d(shape) => shape.bounding_volume(),
+            Self::Shape3d(shape) => shape.bounding_volume(),
         }
+    }
+}
+
+impl Shape for fj::Shape2d {
+    type Brep = Sketch;
 
-        impl Shape for fj::Shape2d {
-            $(
-                fn $method(&self, $($arg_name: $arg_ty,)*) -> $ret {
-                    match self {
-                        Self::Difference(shape) => shape.$method($($arg_name,)*),
-                        Self::Sketch(shape) => shape.$method($($arg_name,)*),
-                    }
-                }
-            )*
+    fn compute_brep(
+        &self,
+        config: &ValidationConfig,
+        tolerance: Tolerance,
+        debug_info: &mut DebugInfo,
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
+        match self {
+            Self::Difference(shape) => {
+                shape.compute_brep(config, tolerance, debug_info)
+            }
+            Self::Sketch(shape) => {
+                shape.compute_brep(config, tolerance, debug_info)
+            }
         }
+    }
 
-        impl Shape for fj::Shape3d {
-            $(
-                fn $method(&self, $($arg_name: $arg_ty,)*) -> $ret {
-                    match self {
-                        Self::Group(shape) => shape.$method($($arg_name,)*),
-                        Self::Sweep(shape) => shape.$method($($arg_name,)*),
-                        Self::Transform(shape) => shape.$method($($arg_name,)*),
-                    }
-                }
-            )*
+    fn bounding_volume(&self) -> Aabb<3> {
+        match self {
+            Self::Difference(shape) => shape.bounding_volume(),
+            Self::Sketch(shape) => shape.bounding_volume(),
         }
-    };
+    }
 }
 
-dispatch! {
-    compute_brep(
+impl Shape for fj::Shape3d {
+    type Brep = Solid;
+
+    fn compute_brep(
+        &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError>;
-    bounding_volume() -> Aabb<3>;
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
+        match self {
+            Self::Group(shape) => {
+                shape.compute_brep(config, tolerance, debug_info)
+            }
+            Self::Sweep(shape) => {
+                shape.compute_brep(config, tolerance, debug_info)
+            }
+            Self::Transform(shape) => {
+                shape.compute_brep(config, tolerance, debug_info)
+            }
+        }
+    }
+
+    fn bounding_volume(&self) -> Aabb<3> {
+        match self {
+            Self::Group(shape) => shape.bounding_volume(),
+            Self::Sweep(shape) => shape.bounding_volume(),
+            Self::Transform(shape) => shape.bounding_volume(),
+        }
+    }
 }

crates/fj-operations/src/sketch.rs

@@ -1,23 +1,25 @@
 use fj_interop::debug::DebugInfo;
 use fj_kernel::{
     algorithms::Tolerance,
-    objects::{Cycle, Edge, Face, Surface},
+    objects::{Cycle, Edge, Face, Sketch, Surface},
     validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::{Aabb, Point, Scalar};
 
 use super::Shape;
 
 impl Shape for fj::Sketch {
+    type Brep = Sketch;
+
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         _: Tolerance,
         _: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError> {
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
         let surface = Surface::xy_plane();
 
-        let sketch = match self.chain() {
+        let face = match self.chain() {
             fj::Chain::Circle(circle) => {
                 // Circles have just a single round edge with no vertices. So
                 // none need to be added here.
@@ -39,7 +41,8 @@ impl Shape for fj::Sketch {
             }
         };
 
-        validate(vec![sketch], config)
+        let sketch = Sketch::from_faces([face]);
+        validate(sketch, config)
     }
 
     fn bounding_volume(&self) -> Aabb<3> {

crates/fj-operations/src/sweep.rs

@@ -1,33 +1,29 @@
 use fj_interop::debug::DebugInfo;
 use fj_kernel::{
     algorithms::{sweep, Tolerance},
-    objects::{Face, Sketch},
+    objects::Solid,
     validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::{Aabb, Vector};
 
 use super::Shape;
 
 impl Shape for fj::Sweep {
+    type Brep = Solid;
+
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError> {
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
         let sketch =
             self.shape().compute_brep(config, tolerance, debug_info)?;
         let path = Vector::from(self.path());
         let color = self.shape().color();
 
-        let solid = sweep(
-            Sketch::from_faces(sketch.into_inner()),
-            path,
-            tolerance,
-            color,
-        );
-
-        validate(solid.into_faces(), config)
+        let solid = sweep(sketch.into_inner(), path, tolerance, color);
+        validate(solid, config)
     }
 
     fn bounding_volume(&self) -> Aabb<3> {

crates/fj-operations/src/transform.rs

@@ -1,28 +1,29 @@
 use fj_interop::debug::DebugInfo;
 use fj_kernel::{
-    algorithms::{transform_faces, Tolerance},
-    objects::Face,
+    algorithms::{Tolerance, TransformObject},
+    objects::Solid,
     validation::{validate, Validated, ValidationConfig, ValidationError},
 };
 use fj_math::{Aabb, Transform, Vector};
 
 use super::Shape;
 
 impl Shape for fj::Transform {
+    type Brep = Solid;
+
     fn compute_brep(
         &self,
         config: &ValidationConfig,
         tolerance: Tolerance,
         debug_info: &mut DebugInfo,
-    ) -> Result<Validated<Vec<Face>>, ValidationError> {
-        let mut shape = self
+    ) -> Result<Validated<Self::Brep>, ValidationError> {
+        let original = self
             .shape
             .compute_brep(config, tolerance, debug_info)?
             .into_inner();
 
-        transform_faces(&mut shape, &make_transform(self));
-
-        validate(shape, config)
+        let transformed = original.transform(&make_transform(self));
+        validate(transformed, config)
     }
 
     fn bounding_volume(&self) -> Aabb<3> {