Simplify STL output and remove readMesh() C++ bridge

Compute face normals from vertex cross products directly instead of
pre-calculating them via calculateNormals. Use meshGL().vertices for
vertex access, removing the need for the readMesh() C++ bridging method
that had relied on cadova.BulkReadMesh.

Author: tomasf

Package.resolved

@@ -1,6 +1,5 @@
 import Manifold3D
 import Foundation
-internal import CadovaCPP
 
 public protocol ConcreteGeometry {
     associatedtype Vector
@@ -64,35 +63,3 @@ extension Vector3D {
     }
 }
 
-extension Manifold {
-    func readMesh() -> (vertices: [Vector3D], triangles: [Manifold3D.Triangle], originalIDs: [Manifold.OriginalID: IndexSet]) {
-        var vertices: [Vector3D] = []
-        var triangles: [Manifold3D.Triangle] = []
-        var originalIDs: [Manifold.OriginalID: IndexSet] = [:]
-
-        cadova.BulkReadMesh(mesh, { properties, vertexCount, propertyCount in
-            guard let properties else { return }
-            for i in 0..<vertexCount {
-                vertices.append(Vector3D(properties[propertyCount * i], properties[propertyCount * i + 1], properties[propertyCount * i + 2]))
-            }
-        }, { indices, triangleCount in
-            guard let indices else { return }
-            for i in 0..<triangleCount {
-                triangles.append(Manifold3D.Triangle(Int(indices[i * 3]), Int(indices[i * 3 + 1]), Int(indices[i * 3 + 2])))
-            }
-
-        }, { runIndex, runIndexCount, runOriginalIDs, runOriginalIDCount in
-            guard let runIndex, let runOriginalIDs else { return }
-
-            let ranges = (0..<runIndexCount).paired().map { index1, index2 in
-                Int(runIndex[index1] / 3)..<Int(runIndex[index2] / 3)
-            }
-            originalIDs = ranges.enumerated().reduce(into: [:]) { result, item in
-                let originalID = Int(runOriginalIDs[item.offset])
-                result[originalID, default: IndexSet()].insert(integersIn: item.element)
-            }
-        })
-
-        return (vertices, triangles, originalIDs)
-    }
-}

Sources/Cadova/Concrete Layer/ConcreteGeometry.swift

@@ -14,8 +14,7 @@ struct BinarySTLDataProvider: OutputDataProvider {
         let allParts = [result] + solidParts
         let union = GeometryNode.boolean(allParts.map(\.node), type: .union)
 
-        var concrete = try await context.result(for: union).concrete
-        concrete = concrete.calculateNormals(channelIndex: 0)
+        let concrete = try await context.result(for: union).concrete
         let meshGL = concrete.meshGL()
 
         let metadata = options[Metadata.self]
@@ -27,16 +26,12 @@ struct BinarySTLDataProvider: OutputDataProvider {
     }
 
     private func stlData(for meshGL: MeshGL, header: String) -> Data {
-        let properties = meshGL.vertexProperties
-        let propertyCount = meshGL.propertyCount
+        let vertices = meshGL.vertices
         let triangles = meshGL.triangles
 
-        assert(properties.count == meshGL.vertexCount * 6) // XYZ + normals
-
-        func double(at vertexIndex: Int, offset: Int) -> Double { properties[vertexIndex * propertyCount + offset] }
-        func position(at index: Int) -> Vector3D { Vector3D(x: double(at: index, offset: 0), y: double(at: index, offset: 1), z: double(at: index, offset: 2)) }
-        func normal(at index: Int) -> Vector3D { Vector3D(x: double(at: index, offset: 3), y: double(at: index, offset: 4), z: double(at: index, offset: 5)) }
-        func triangleNormal(_ triangle: Manifold3D.Triangle) -> Vector3D { (normal(at: triangle.a) + normal(at: triangle.b) + normal(at: triangle.c)).normalized }
+        func triangleNormal(_ triangle: Manifold3D.Triangle) -> Vector3D {
+            ((vertices[triangle.b] - vertices[triangle.a]) × (vertices[triangle.c] - vertices[triangle.a])).normalized
+        }
 
         func append(_ int: UInt32) {
             var value = int.littleEndian
@@ -74,9 +69,9 @@ struct BinarySTLDataProvider: OutputDataProvider {
 
         for triangle in triangles {
             append(triangleNormal(triangle))
-            append(position(at: triangle.a))
-            append(position(at: triangle.b))
-            append(position(at: triangle.c))
+            append(vertices[triangle.a])
+            append(vertices[triangle.b])
+            append(vertices[triangle.c])
             append(UInt16(0)) // attribute byte count
         }