Merge branch 'dev'

Author: tomasf

Sources/Cadova/Abstract Layer/Environment/Environment.swift

@@ -16,7 +16,7 @@ import Foundation
 ///   - keyPath: A key path to the value in `EnvironmentValues`, which determines the specific value to read.
 ///
 @propertyWrapper public struct Environment<T: Sendable>: Sendable {
-    private let getter: @Sendable (EnvironmentValues) -> T
+    internal let getter: @Sendable (EnvironmentValues) -> T
 
     public init() where T == EnvironmentValues {
         getter = { $0 }

Sources/Cadova/Abstract Layer/Environment/EnvironmentValues.swift

@@ -14,6 +14,11 @@ public struct EnvironmentValues: Sendable {
         self.values = values
     }
 
+    init<T: Sendable>(keyPath: WritableKeyPath<Self, T>, value: T) {
+        self.init()
+        self[keyPath: keyPath] = value
+    }
+
     /// Returns a new environment by adding new values to the current environment.
     ///
     /// - Parameter newValues: A dictionary of values to add to the environment.

Sources/Cadova/Abstract Layer/Geometry/ApplyMaterial.swift

@@ -37,6 +37,14 @@ public extension Geometry3D {
     func colored(red: Double, green: Double, blue: Double, alpha: Double = 1) -> any Geometry3D {
         colored(.init(red: red, green: green, blue: blue, alpha: alpha))
     }
+
+    /// Applies a color to the geometry using a hexadecimal string.
+    ///
+    /// - Parameter hex: A string containing 6 or 8 hexadecimal digits (optionally with a leading “#”).
+    /// - Returns: A geometry instance with the given color applied.
+    func colored(hex: String) -> any Geometry3D {
+        colored(Color(hex: hex))
+    }
 }
 
 public extension Geometry3D {

Sources/Cadova/Abstract Layer/Geometry/BuildResult.swift

@@ -62,6 +62,12 @@ internal extension BuildResult {
     }
 }
 
+internal extension BuildResult<D2> {
+    func promotedTo3D() -> BuildResult<D3> {
+        replacing(node: .extrusion(node, type: .linear(height: 0.001)))
+    }
+}
+
 extension BuildResult: Geometry {
     public func build(in environment: EnvironmentValues, context: EvaluationContext) async throws -> D.BuildResult {
         self

Sources/Cadova/Abstract Layer/Geometry/CachingGeometryTypes.swift

@@ -63,55 +63,6 @@ struct CachedConcreteTransformer<D: Dimensionality, Key: CacheKey>: Geometry {
     }
 }
 
-// Apply an arbitrary transformation to a body's concrete, returning a variable number
-// of resulting concretes, individually cached based on node + key + index
-
-struct CachedConcreteArrayTransformer<D: Dimensionality, Key: CacheKey>: Geometry {
-    let body: D.Geometry
-    let key: Key
-    let generator: @Sendable (D.Concrete) throws -> [D.Concrete]
-    let resultHandler: @Sendable ([D.Geometry]) -> D.Geometry
-
-    init(
-        body: D.Geometry,
-        key: Key, generator: @Sendable @escaping (D.Concrete) throws -> [D.Concrete],
-        resultHandler: @Sendable @escaping ([D.Geometry]) -> D.Geometry
-    ) {
-        self.body = body
-        self.key = key
-        self.generator = generator
-        self.resultHandler = resultHandler
-    }
-
-    init(
-        body: D.Geometry,
-        name: String,
-        parameters: any CacheKey...,
-        generator: @Sendable @escaping (D.Concrete) throws -> [D.Concrete],
-        resultHandler: @Sendable @escaping ([D.Geometry]) -> D.Geometry
-    ) where Key == LabeledCacheKey {
-        self.init(
-            body: body,
-            key: LabeledCacheKey(operationName: name, parameters: parameters),
-            generator: generator,
-            resultHandler: resultHandler
-        )
-    }
-
-    func build(in environment: EnvironmentValues, context: EvaluationContext) async throws -> D.BuildResult {
-        let bodyResult = try await context.buildResult(for: body, in: environment)
-        let bakedKey = NodeCacheKey(base: key, node: bodyResult.node)
-
-        let geometries = try await context.multipartMaterializedResults(for: bakedKey, from: bodyResult) {
-            let nodeResult = try await context.result(for: bodyResult.node)
-            let concretes = try generator(nodeResult.concrete)
-            return try concretes.map { try D.Node.Result($0) }
-        }
-
-        return try await context.buildResult(for: resultHandler(geometries), in: environment)
-    }
-}
-
 // Apply an arbitrary transformation to a node, cached based on node + key
 
 struct CachedNodeTransformer<D: Dimensionality, Input: Dimensionality>: Geometry {

Sources/Cadova/Abstract Layer/Operations/Duplication/RepeatAlong.swift

@@ -99,6 +99,7 @@ extension Geometry {
             let count = Int(floor(availableLength / (boundsLength + minimumSpacing)))
             let step = availableLength / Double(count)
             self.repeated(along: axis, step: step, count: count + 1)
+                .translated(D.Vector(axis, value: range.lowerBound))
         }
     }
 }

Sources/Cadova/Abstract Layer/Operations/Separate.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+internal struct Separate<D: Dimensionality>: Geometry {
+    let body: D.Geometry
+    let reader: @Sendable ([D.Geometry]) -> D.Geometry
+
+    public func build(in environment: EnvironmentValues, context: EvaluationContext) async throws -> D.BuildResult {
+        let result = try await context.buildResult(for: body, in: environment)
+        let partCount = try await context.result(for: .decompose(result.node)).parts.count
+        let parts = (0..<partCount).map { SeparatedPart(body: body, index: $0) }
+        return try await context.buildResult(for: reader(parts), in: environment)
+    }
+}
+
+internal struct SeparatedPart<D: Dimensionality>: Geometry {
+    let body: D.Geometry
+    let index: Int
+
+    public func build(in environment: EnvironmentValues, context: EvaluationContext) async throws -> D.BuildResult {
+        try await context.buildResult(for: body, in: environment).modifyingNode {
+            .select(.decompose($0), index: index)
+        }
+    }
+}
+
+public extension Geometry {
+    /// Splits the geometry into its disconnected components and passes them to a reader closure.
+    ///
+    /// This method identifies and extracts all topologically disconnected parts of the geometry,
+    /// such as individual shells or pieces that do not touch each other. The resulting components
+    /// are passed to a closure, allowing you to process, rearrange, or visualize them as desired.
+    ///
+    /// - Parameter reader: A closure that takes the array of separated components and returns a new geometry.
+    /// - Returns: A new geometry built from the components returned by the `reader` closure.
+    ///
+    /// ## Example
+    /// ```swift
+    /// model.separated { components in
+    ///     Stack(.x, spacing: 1) {
+    ///         for component in components {
+    ///             component
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// In this example, each disconnected part of the model is extracted and displayed side-by-side
+    /// along the X axis with a spacing of 1 mm.
+    func separated(@GeometryBuilder<D> reader: @Sendable @escaping (_ components: [D.Geometry]) -> D.Geometry) -> D.Geometry {
+        Separate(body: self, reader: reader)
+    }
+}

Sources/Cadova/Abstract Layer/Operations/Split.swift

@@ -28,17 +28,10 @@ public extension Geometry3D {
         along plane: Plane,
         @GeometryBuilder3D reader: @Sendable @escaping (_ over: any Geometry3D, _ under: any Geometry3D) -> any Geometry3D
     ) -> any Geometry3D {
-        CachedConcreteArrayTransformer(body: self, name: "Cadova.SplitAlongPlane", parameters: plane) { input in
-            let (a, b) = input.translate(-plane.offset)
-                .split(by: plane.normal.unitVector, originOffset: 0)
-            return [a, b]
-        } resultHandler: { geometries in
-            precondition(geometries.count == 2, "Split result should contain exactly two geometries")
-            return reader(
-                geometries[0].translated(plane.offset),
-                geometries[1].translated(plane.offset)
-            )
-        }
+        reader(
+            GeometryNodeTransformer(body: self) { .trim($0, plane: plane) },
+            GeometryNodeTransformer(body: self) { .trim($0, plane: plane.flipped) }
+        )
     }
 
     /// Splits the geometry into two parts along the specified plane and arranges them side-by-side.
@@ -94,19 +87,7 @@ public extension Geometry3D {
         @GeometryBuilder3D with mask: @escaping () -> any Geometry3D,
         @GeometryBuilder3D result: @Sendable @escaping (_ inside: any Geometry3D, _ outside: any Geometry3D) -> any Geometry3D
     ) -> any Geometry3D {
-        mask().readingConcrete { concrete, maskResult in
-            CachedConcreteArrayTransformer(body: self, name: "Cadova.SplitWithMask", parameters: maskResult.node) { input in
-                let (a, b) = input.split(by: concrete)
-                return [a, b]
-            } resultHandler: { geometries in
-                precondition(geometries.count == 2, "Split result should contain exactly two geometries")
-
-                return result(
-                    geometries[0].mergingResultElements(with: maskResult.elements),
-                    geometries[1].mergingResultElements(with: maskResult.elements)
-                )
-            }
-        }
+        result(intersecting(mask()), subtracting(mask()))
     }
 
     /// Trims the geometry along the specified plane, keeping only the portion facing the plane's normal direction.
@@ -128,35 +109,3 @@ public extension Geometry3D {
         GeometryNodeTransformer(body: self) { .trim($0, plane: plane) }
     }
 }
-
-public extension Geometry {
-    /// Splits the geometry into its disconnected components and passes them to a reader closure.
-    ///
-    /// This method identifies and extracts all topologically disconnected parts of the geometry,
-    /// such as individual shells or pieces that do not touch each other. The resulting components
-    /// are passed to a closure, allowing you to process, rearrange, or visualize them as desired.
-    ///
-    /// - Parameter reader: A closure that takes the array of separated components and returns a new geometry.
-    /// - Returns: A new geometry built from the components returned by the `reader` closure.
-    ///
-    /// ## Example
-    /// ```swift
-    /// model.separated { components in
-    ///     Stack(.x, spacing: 1) {
-    ///         for component in components {
-    ///             component
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// In this example, each disconnected part of the model is extracted and displayed side-by-side
-    /// along the X axis with a spacing of 1 mm.
-    func separated(@GeometryBuilder<D> reader: @Sendable @escaping (_ components: [D.Geometry]) -> D.Geometry) -> D.Geometry {
-        CachedConcreteArrayTransformer(body: self, name: "Cadova.Separate") {
-            $0.decompose()
-        } resultHandler: {
-            reader($0)
-        }
-    }
-}

Sources/Cadova/Abstract Layer/Operations/Transformations/RotateAround.swift

@@ -77,6 +77,21 @@ public extension Geometry3D {
                 .rotated(x: x, y: y, z: z)
                 .translated(-translation)
         }
+    }
 
+    /// Rotates the geometry around an arbitrary axis defined by a 3D line.
+    ///
+    /// The axis of rotation is given by the line’s direction and passes through a point on the line.
+    ///
+    /// - Parameters:
+    ///   - angle: The angle to rotate around the axis.
+    ///   - axis: A line in 3D defining the rotation axis (direction) and the point it passes through.
+    /// - Returns: A new geometry that is the result of applying the specified rotation around the line.
+    ///
+    func rotated(_ angle: Angle, around axis: Line<D3>) -> any Geometry3D {
+        self
+            .translated(-axis.point)
+            .transformed(.rotation(angle: angle, around: axis.direction))
+            .translated(axis.point)
     }
 }

Sources/Cadova/Concrete Layer/Build/BuildDirective.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+public struct BuildDirective: Sendable {
+    internal let payload: Payload
+
+    internal enum Payload: Sendable {
+        case geometry2D (any Geometry2D)
+        case geometry3D (any Geometry3D)
+        case model (Model)
+        case options (ModelOptions)
+        case environment (@Sendable (inout EnvironmentValues) -> ())
+    }
+
+    var geometry2D: (any Geometry2D)? {
+        if case .geometry2D(let geometry2D) = payload { geometry2D } else { nil }
+    }
+
+    var geometry3D: (any Geometry3D)? {
+        if case .geometry3D(let geometry3D) = payload { geometry3D } else { nil }
+    }
+
+    var model: Model? {
+        if case .model(let model) = payload { model } else { nil }
+    }
+
+    var options: ModelOptions? {
+        if case .options(let options) = payload { options } else { nil }
+    }
+
+    var environment: ((inout EnvironmentValues) -> ())? {
+        if case .environment(let environment) = payload { environment } else { nil }
+    }
+}
+
+// This is a bit of a hack to allow the use of Environment inside result builders
+public extension Environment<@Sendable (inout EnvironmentValues) -> ()> {
+    init(_ builder: @Sendable @escaping (inout EnvironmentValues) -> ()) {
+        getter = { _ in builder }
+    }
+
+    init<Value: Sendable>(
+        _ keyPath: WritableKeyPath<EnvironmentValues, Value>,
+        _ value: Value
+    ){
+        getter = { _ in { $0[keyPath: keyPath] = value }}
+    }
+}