fluidcad 0.0.26 → 0.0.27

package/lib/dist/oc/mesh.js

@@ -1,4 +1,7 @@
 import { getOC } from "./init.js";
+// Flip to false to benchmark single-threaded meshing.
+const DEFAULT_LIN_DEFLECTION = 0.1;
+const DEFAULT_ANG_DEFLECTION = 0.5;
 export class Mesh {
     // Wrapper methods (public API for external callers)
     static triangulateFace(face, vertexOffset = 0) {
@@ -7,23 +10,33 @@ export class Mesh {
     static discretizeEdge(edge) {
         return Mesh.discretizeEdgeRaw(edge.getShape());
     }
-    static premeshShape(shape) {
+    /**
+     * Triangulates `shape` only if it doesn't already have an up-to-date
+     * triangulation at the requested deflection. Returns true when a fresh
+     * mesh was built, false when the stored one was reused.
+     */
+    static ensureTriangulated(shape, opts = {}) {
         const oc = getOC();
-        const inc = new oc.BRepMesh_IncrementalMesh(shape, 0.3, false, 0.3, true);
+        const linDefl = opts.linDefl ?? DEFAULT_LIN_DEFLECTION;
+        const angDefl = opts.angDefl ?? DEFAULT_ANG_DEFLECTION;
+        const relative = opts.relative ?? false;
+        const checkFreeEdges = opts.checkFreeEdges ?? true;
+        if (oc.BRepTools.Triangulation(shape, linDefl, checkFreeEdges)) {
+            return false;
+        }
+        const inc = new oc.BRepMesh_IncrementalMesh(shape, linDefl, relative, angDefl, false);
         inc.delete();
+        return true;
     }
     // Raw methods (for oc-internal use)
     static triangulateFaceRaw(face, vertexOffset = 0) {
-        const oc = getOC();
-        let inc;
         try {
-            inc = new oc.BRepMesh_IncrementalMesh(face, 0.3, false, 0.3, true);
+            Mesh.ensureTriangulated(face);
         }
         catch (e) {
             console.error("Face mesh failed", e);
             return null;
         }
-        inc.delete();
         return Mesh.extractFaceTriangulationRaw(face, vertexOffset);
     }
     static extractFaceTriangulationRaw(face, vertexOffset = 0) {
@@ -80,39 +93,103 @@ export class Mesh {
         aLocation.delete();
         return { vertices, normals, indices, count: nbNodes };
     }
+    /**
+     * Reads the polyline stored for `edge` as a polygon-on-triangulation of
+     * `face`. Node indices point into the face's triangulation, so the edge
+     * samples coincide exactly with the face mesh vertices (watertight).
+     */
+    static discretizeEdgeOnFace(edge, face) {
+        const oc = getOC();
+        if (oc.BRep_Tool.Degenerated(edge)) {
+            return null;
+        }
+        const loc = new oc.TopLoc_Location();
+        const triHandle = oc.BRep_Tool.Triangulation(face, loc, 0);
+        if (triHandle.IsNull()) {
+            triHandle.delete();
+            loc.delete();
+            return null;
+        }
+        const polyHandle = oc.BRep_Tool.PolygonOnTriangulation(edge, triHandle, loc);
+        if (polyHandle.IsNull()) {
+            polyHandle.delete();
+            triHandle.delete();
+            loc.delete();
+            return null;
+        }
+        const tri = triHandle.get();
+        const poly = polyHandle.get();
+        const nbNodes = poly.NbNodes();
+        const tx = loc.Transformation();
+        const vertices = new Array(nbNodes * 3);
+        for (let i = 1; i <= nbNodes; i++) {
+            const nodeIdx = poly.Node(i);
+            const p = tri.Node(nodeIdx);
+            const pT = p.Transformed(tx);
+            const base = (i - 1) * 3;
+            vertices[base] = pT.X();
+            vertices[base + 1] = pT.Y();
+            vertices[base + 2] = pT.Z();
+            p.delete();
+            pT.delete();
+        }
+        const indices = new Array((nbNodes - 1) * 2);
+        for (let i = 0; i < nbNodes - 1; i++) {
+            indices[i * 2] = i;
+            indices[i * 2 + 1] = i + 1;
+        }
+        tx.delete();
+        polyHandle.delete();
+        triHandle.delete();
+        loc.delete();
+        return { vertices, normals: [], indices };
+    }
+    /**
+     * Reads the stored 3D polygon for a free edge (one not attached to a
+     * meshed face). Caller must have already run `ensureTriangulated` on the
+     * edge or its parent wire.
+     */
     static discretizeEdgeRaw(edge) {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
-        const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
-        const type = adaptor.GetType();
-        const first = adaptor.FirstParameter();
-        const last = adaptor.LastParameter();
-        const points = [];
-        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
-            const startPnt = adaptor.Value(first);
-            const endPnt = adaptor.Value(last);
-            points.push(startPnt.X(), startPnt.Y(), startPnt.Z());
-            points.push(endPnt.X(), endPnt.Y(), endPnt.Z());
-            startPnt.delete();
-            endPnt.delete();
-        }
-        else {
-            const numSegments = Math.max(1, Math.floor((last - first) / 0.01));
-            for (let i = 0; i <= numSegments; i++) {
-                const t = first + ((last - first) * i) / numSegments;
-                const pnt = adaptor.Value(t);
-                points.push(pnt.X(), pnt.Y(), pnt.Z());
-                pnt.delete();
-            }
+        if (oc.BRep_Tool.Degenerated(ocEdge)) {
+            ocEdge.delete();
+            return { vertices: [], normals: [], indices: [] };
         }
-        adaptor.delete();
-        ocEdge.delete();
-        const pointCount = points.length / 3;
-        const indices = [];
-        for (let i = 0; i < pointCount - 1; i++) {
-            indices[2 * i] = i;
-            indices[2 * i + 1] = i + 1;
+        Mesh.ensureTriangulated(edge);
+        const loc = new oc.TopLoc_Location();
+        const polyHandle = oc.BRep_Tool.Polygon3D(ocEdge, loc);
+        if (polyHandle.IsNull()) {
+            polyHandle.delete();
+            loc.delete();
+            ocEdge.delete();
+            console.warn("Edge has no stored Polygon3D after meshing; returning empty polyline.");
+            return { vertices: [], normals: [], indices: [] };
         }
-        return { vertices: points, normals: [], indices };
+        const poly = polyHandle.get();
+        const nbNodes = poly.NbNodes();
+        const nodes = poly.Nodes();
+        const tx = loc.Transformation();
+        const vertices = new Array(nbNodes * 3);
+        for (let i = 1; i <= nbNodes; i++) {
+            const p = nodes.Value(i);
+            const pT = p.Transformed(tx);
+            const base = (i - 1) * 3;
+            vertices[base] = pT.X();
+            vertices[base + 1] = pT.Y();
+            vertices[base + 2] = pT.Z();
+            p.delete();
+            pT.delete();
+        }
+        const indices = new Array((nbNodes - 1) * 2);
+        for (let i = 0; i < nbNodes - 1; i++) {
+            indices[i * 2] = i;
+            indices[i * 2 + 1] = i + 1;
+        }
+        tx.delete();
+        polyHandle.delete();
+        loc.delete();
+        ocEdge.delete();
+        return { vertices, normals: [], indices };
     }
 }

package/lib/dist/oc/shape-ops.d.ts

@@ -1,11 +1,7 @@
-import type { TopTools_ListOfShape, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid } from "occjs-wrapper";
+import type { TopTools_ListOfShape, TopoDS_Shape } from "occjs-wrapper";
 import { Matrix4 } from "../math/matrix4.js";
-import { Vector3d } from "../math/vector3d.js";
 import { Shape } from "../common/shape.js";
-import { Face } from "../common/face.js";
-import { Solid } from "../common/solid.js";
 import { BoundingBox } from "../helpers/types.js";
-import { Axis } from "../math/axis.js";
 export declare class ShapeOps {
     static transform(shape: Shape, matrix: Matrix4): Shape;
     static getBoundingBox(shape: Shape | TopoDS_Shape): BoundingBox;
@@ -14,21 +10,5 @@ export declare class ShapeOps {
     static makeCompoundRaw(shapes: TopoDS_Shape[]): import("occjs-wrapper").TopoDS_Compound;
     static cleanShape(shape: Shape): Shape;
     static cleanShapeRaw(shape: TopoDS_Shape): TopoDS_Shape;
-    static getSolidOutwardNormal(face: Face, solid: Solid): Vector3d;
-    static getSolidOutwardNormalRaw(face: TopoDS_Face, solid: TopoDS_Solid): Vector3d;
-    static mirrorShape(shape: Shape, mirrorPoint: {
-        x: number;
-        y: number;
-        z: number;
-    }): Shape;
-    static mirrorShapeRaw(shape: TopoDS_Shape, mirrorPoint: {
-        x: number;
-        y: number;
-        z: number;
-    }): TopoDS_Shape;
-    static translateShape(shape: Shape, direction: Vector3d): Shape;
-    static translateShapeRaw(shape: TopoDS_Shape, direction: Vector3d): TopoDS_Shape;
-    static rotateShape(shape: TopoDS_Shape, axis: Axis, angle: number): TopoDS_Shape;
     static shapeListToArray(list: TopTools_ListOfShape): TopoDS_Shape[];
-    static edgeMiddlePoint(edge: TopoDS_Edge): import("occjs-wrapper").gp_Pnt;
 }

package/lib/dist/oc/shape-ops.js

@@ -1,6 +1,5 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
-import { Vector3d } from "../math/vector3d.js";
 import { Shape } from "../common/shape.js";
 import { ShapeFactory } from "../common/shape-factory.js";
 export class ShapeOps {
@@ -94,98 +93,6 @@ export class ShapeOps {
         progress.delete();
         return fixed;
     }
-    static getSolidOutwardNormal(face, solid) {
-        return ShapeOps.getSolidOutwardNormalRaw(face.getShape(), solid.getShape());
-    }
-    static getSolidOutwardNormalRaw(face, solid) {
-        const oc = getOC();
-        const surfaceAdaptor = new oc.BRepAdaptor_Surface(face, true);
-        const type = surfaceAdaptor.GetType();
-        if (type !== oc.GeomAbs_SurfaceType.GeomAbs_Plane) {
-            surfaceAdaptor.delete();
-            throw new Error("Non-planar faces not supported for normal calculation");
-        }
-        const uFirst = surfaceAdaptor.FirstUParameter();
-        const uLast = surfaceAdaptor.LastUParameter();
-        const vFirst = surfaceAdaptor.FirstVParameter();
-        const vLast = surfaceAdaptor.LastVParameter();
-        const u = (uFirst + uLast) / 2.0;
-        const v = (vFirst + vLast) / 2.0;
-        const testPoint = new oc.gp_Pnt();
-        const du = new oc.gp_Vec();
-        const dv = new oc.gp_Vec();
-        surfaceAdaptor.D1(u, v, testPoint, du, dv);
-        const geometricNormal = surfaceAdaptor.Plane().Position().Direction();
-        if (face.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
-            geometricNormal.Reverse();
-        }
-        const offset = 1e-6;
-        const testPointOffset = new oc.gp_Pnt(testPoint.X() + geometricNormal.X() * offset, testPoint.Y() + geometricNormal.Y() * offset, testPoint.Z() + geometricNormal.Z() * offset);
-        const classifier = new oc.BRepClass3d_SolidClassifier(solid, testPointOffset, oc.Precision.Confusion());
-        const state = classifier.State();
-        let result;
-        if (state === oc.TopAbs_State.TopAbs_IN) {
-            result = new Vector3d(-geometricNormal.X(), -geometricNormal.Y(), -geometricNormal.Z());
-        }
-        else {
-            result = new Vector3d(geometricNormal.X(), geometricNormal.Y(), geometricNormal.Z());
-        }
-        classifier.delete();
-        testPointOffset.delete();
-        geometricNormal.delete();
-        du.delete();
-        dv.delete();
-        testPoint.delete();
-        surfaceAdaptor.delete();
-        return result;
-    }
-    static mirrorShape(shape, mirrorPoint) {
-        const result = ShapeOps.mirrorShapeRaw(shape.getShape(), mirrorPoint);
-        return ShapeFactory.fromShape(result);
-    }
-    static mirrorShapeRaw(shape, mirrorPoint) {
-        const oc = getOC();
-        const point = new oc.gp_Pnt(mirrorPoint.x, mirrorPoint.y, mirrorPoint.z);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetMirror(point);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, true);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        point.delete();
-        return result;
-    }
-    static translateShape(shape, direction) {
-        const result = ShapeOps.translateShapeRaw(shape.getShape(), direction);
-        return ShapeFactory.fromShape(result);
-    }
-    static translateShapeRaw(shape, direction) {
-        const oc = getOC();
-        const [vec, disposeVec] = Convert.toGpVec(direction);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetTranslation(vec);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, false);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        disposeVec();
-        return result;
-    }
-    static rotateShape(shape, axis, angle) {
-        const oc = getOC();
-        const trsf = new oc.gp_Trsf();
-        const [gpAxis, disposeGpAxis] = Convert.toGpAx1(axis);
-        trsf.SetRotation(gpAxis, angle);
-        const transformer = new oc.BRepBuilderAPI_Transform(trsf);
-        transformer.Perform(shape, false);
-        const result = transformer.Shape();
-        transformer.delete();
-        trsf.delete();
-        disposeGpAxis();
-        return result;
-    }
     static shapeListToArray(list) {
         let res = [];
         while (list.Size() > 0) {
@@ -195,14 +102,4 @@ export class ShapeOps {
         list.delete();
         return res;
     }
-    static edgeMiddlePoint(edge) {
-        const oc = getOC();
-        const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
-        const curve = curveAdaptor.Curve();
-        const midParam = (curve.FirstParameter() + curve.LastParameter()) / 2.0;
-        const midPoint = curve.Value(midParam);
-        const result = new oc.gp_Pnt(midPoint.X(), midPoint.Y(), midPoint.Z());
-        curveAdaptor.delete();
-        return result;
-    }
 }

package/lib/dist/rendering/mesh-transform.js

@@ -1,5 +1,12 @@
 export function transformMeshes(meshes, matrix) {
     const m = matrix.elements;
+    // Determinant of the 3x3 linear part. Negative for mirror/reflection
+    // transforms — those flip triangle winding, so we have to swap indices
+    // to keep faces front-facing after the vertex transform.
+    const det3 = m[0] * (m[5] * m[10] - m[9] * m[6]) -
+        m[4] * (m[1] * m[10] - m[9] * m[2]) +
+        m[8] * (m[1] * m[6] - m[5] * m[2]);
+    const flipWinding = det3 < 0;
     return meshes.map(mesh => {
         const srcV = mesh.vertices;
         const srcN = mesh.normals;
@@ -17,6 +24,15 @@ export function transformMeshes(meshes, matrix) {
             newN[i + 1] = m[1] * nx + m[5] * ny + m[9] * nz;
             newN[i + 2] = m[2] * nx + m[6] * ny + m[10] * nz;
         }
-        return { ...mesh, vertices: newV, normals: newN };
+        let newIndices = mesh.indices;
+        if (flipWinding && mesh.indices.length % 3 === 0) {
+            newIndices = new Array(mesh.indices.length);
+            for (let i = 0; i < mesh.indices.length; i += 3) {
+                newIndices[i] = mesh.indices[i];
+                newIndices[i + 1] = mesh.indices[i + 2];
+                newIndices[i + 2] = mesh.indices[i + 1];
+            }
+        }
+        return { ...mesh, vertices: newV, normals: newN, indices: newIndices };
     });
 }

package/lib/dist/rendering/render-solid.js

@@ -1,23 +1,36 @@
-import { renderEdge } from "./render-edge.js";
 import { Explorer } from "../oc/explorer.js";
 import { Mesh } from "../oc/mesh.js";
+import { getOC } from "../oc/init.js";
 export function renderSolid(shapeObj) {
-    Mesh.premeshShape(shapeObj.getShape());
+    Mesh.ensureTriangulated(shapeObj.getShape());
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];
 }
 function getEdgesMesh(shapeObj) {
+    const oc = getOC();
     const result = [];
+    const edgeToFaces = new oc.TopTools_IndexedDataMapOfShapeListOfShape();
+    oc.TopExp.MapShapesAndAncestors(shapeObj.getShape(), oc.TopAbs_ShapeEnum.TopAbs_EDGE, oc.TopAbs_ShapeEnum.TopAbs_FACE, edgeToFaces);
     const edges = Explorer.findEdgesWrapped(shapeObj);
     for (let edgeIdx = 0; edgeIdx < edges.length; edgeIdx++) {
-        const edgeResult = renderEdge(edges[edgeIdx]);
+        const edgeShape = edges[edgeIdx].getShape();
+        const parents = edgeToFaces.Seek(edgeShape);
+        if (!parents || parents.Size() === 0) {
+            continue;
+        }
+        const parentFace = oc.TopoDS.Face(parents.First());
+        const edgeResult = Mesh.discretizeEdgeOnFace(edgeShape, parentFace);
+        parentFace.delete();
         if (edgeResult) {
-            edgeResult.label = 'solid-edges';
-            edgeResult.edgeIndex = edgeIdx;
-            result.push(edgeResult);
+            result.push({
+                ...edgeResult,
+                label: 'solid-edges',
+                edgeIndex: edgeIdx,
+            });
         }
     }
+    edgeToFaces.delete();
     return result;
 }
 function getFacesMesh(shapeObj) {

package/lib/dist/rendering/render-wire.js

@@ -1,8 +1,10 @@
 import { renderEdge } from "./render-edge.js";
 import { Edge } from "../common/edge.js";
 import { Explorer } from "../oc/explorer.js";
+import { Mesh } from "../oc/mesh.js";
 export function renderWire(shapeObj) {
     const shape = shapeObj.getShape();
+    Mesh.ensureTriangulated(shape);
     const edges = Explorer.findShapes(shape, Explorer.getOcShapeType("edge"));
     const allVertices = [];
     const allNormals = [];

package/lib/dist/rendering/render.d.ts

@@ -1,3 +1,13 @@
 import { Scene } from "./scene.js";
-export declare function renderSceneRollback(scene: Scene, rollbackIndex: number): Scene;
-export declare function renderScene(scene: Scene): Scene;
+export declare class SceneRenderer {
+    private readonly meshBuilder;
+    render(scene: Scene): Scene;
+    renderRollback(scene: Scene, rollbackIndex: number): Scene;
+    private renderObject;
+    private buildObject;
+    private getOrBuildMeshes;
+    private toRenderedShape;
+    private computeVisibility;
+    private aggregateContainerDurations;
+    private emitRendered;
+}