fluidcad 0.0.33 → 0.0.34

package/lib/dist/oc/constraints/constraint-solver-adaptor.js

@@ -36,9 +36,25 @@ export class ConstraintSolverAdaptor extends ConstraintSolver {
         console.log('Using geometric solver for tangent circles');
         return this.geometricSolver.getTangentArcs(plane, shape1, shape2, radius, this.mustTouch);
     }
+    getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+        if (this.isLine(target.shape)) {
+            return this.geometricSolver.getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+        }
+        return this.curveSolver.getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+    }
     isCurve(shape) {
         return !(shape instanceof Vertex) && this.getShapeGeometry(shape) === 'curve';
     }
+    isLine(shape) {
+        if (shape instanceof Vertex) {
+            return false;
+        }
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        adaptor.delete();
+        return type === oc.GeomAbs_CurveType.GeomAbs_Line;
+    }
     getShapeGeometry(shape) {
         const oc = getOC();
         const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());

package/lib/dist/oc/constraints/constraint-solver.d.ts

@@ -15,4 +15,8 @@ export declare abstract class ConstraintSolver implements TangentLineSolver, Tan
         edges: Edge[];
         endTangent: Point2D;
     };
+    abstract getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
 }

package/lib/dist/oc/constraints/curve/curve-constraint-solver.d.ts

@@ -10,4 +10,8 @@ export declare class CurveConstraintSolver extends ConstraintSolver {
         edges: Edge[];
         endTangent: Point2D | null;
     };
+    getTangentArcFromPointTangent(_plane: Plane, _startPoint: Point2D, _startTangent: Point2D, _target: QualifiedShape, _flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
 }

package/lib/dist/oc/constraints/curve/curve-constraint-solver.js

@@ -15,4 +15,7 @@ export class CurveConstraintSolver extends ConstraintSolver {
         const solver = new CurveTangentCircleSolver();
         return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
     }
+    getTangentArcFromPointTangent(_plane, _startPoint, _startTangent, _target, _flip) {
+        throw new Error('tArc(target): only line targets are supported');
+    }
 }

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.d.ts

@@ -1,12 +1,17 @@
 import { Edge } from "../../../common/edge.js";
 import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
 import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
 import { ConstraintSolver } from "../constraint-solver.js";
 export declare class GeometricConstraintSolver extends ConstraintSolver {
     getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch: boolean): Edge[];
     getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
     getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
         edges: Edge[];
-        endTangent: import("../../../math/point.js").Point2D | null;
+        endTangent: Point2D | null;
+    };
+    getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
     };
 }

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.js

@@ -1,6 +1,7 @@
 import { ConstraintSolver } from "../constraint-solver.js";
 import { GeometricTangentCircleSolver } from "./tangent-circle-solver.js";
 import { GeometricTangentLineSolver } from "./tangent-line-solver.js";
+import { solveTangentArcFromPointTangent } from "./tangent-arc-from-point-tangent.js";
 export class GeometricConstraintSolver extends ConstraintSolver {
     getTangentLines(plane, shape1, shape2, mustTouch) {
         const tangentLineSolver = new GeometricTangentLineSolver();
@@ -14,4 +15,7 @@ export class GeometricConstraintSolver extends ConstraintSolver {
         const solver = new GeometricTangentCircleSolver();
         return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
     }
+    getTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+        return solveTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip);
+    }
 }

package/lib/dist/oc/constraints/geometric/tangent-arc-from-point-tangent.d.ts

@@ -0,0 +1,8 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
+export declare function solveTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+    edges: Edge[];
+    endTangent: Point2D | null;
+};

package/lib/dist/oc/constraints/geometric/tangent-arc-from-point-tangent.js

@@ -0,0 +1,111 @@
+import { Edge } from "../../../common/edge.js";
+import { Point2D } from "../../../math/point.js";
+import { Geometry } from "../../geometry.js";
+import { getOC } from "../../init.js";
+const EPS = 1e-10;
+export function solveTangentArcFromPointTangent(plane, startPoint, startTangent, target, flip) {
+    const lineTarget = extractLineTarget(plane, target);
+    const tlen = startTangent.length();
+    if (tlen < EPS) {
+        throw new Error('tArc(target): start tangent has zero magnitude');
+    }
+    const Tx = startTangent.x / tlen;
+    const Ty = startTangent.y / tlen;
+    const Nx = -Ty;
+    const Ny = Tx;
+    const Qx = lineTarget.pointOnLine.x;
+    const Qy = lineTarget.pointOnLine.y;
+    const dx = lineTarget.direction.x;
+    const dy = lineTarget.direction.y;
+    const nx = -dy;
+    const ny = dx;
+    const dPL = (startPoint.x - Qx) * nx + (startPoint.y - Qy) * ny;
+    const k = Nx * nx + Ny * ny;
+    // Two candidate signed radii from the line tangency equation:
+    //   d_PL + r·k = s·r  ⇒  r = d_PL / (s − k)  for s ∈ {+1, −1}
+    // Generically one yields r > 0 (center on the +N̂ side = "primary/left")
+    // and the other yields r < 0 ("flipped/right"). Pick by sign so the
+    // user-facing default is deterministic regardless of input geometry.
+    const candidates = [];
+    for (const s of [+1, -1]) {
+        const denom = s - k;
+        if (Math.abs(denom) < EPS) {
+            continue;
+        }
+        const r = dPL / denom;
+        if (Math.abs(r) < EPS) {
+            continue;
+        }
+        candidates.push(buildCandidate(startPoint, Nx, Ny, r, lineTarget));
+    }
+    if (candidates.length === 0) {
+        return { edges: [], endTangent: null };
+    }
+    const primary = candidates.find(c => c.ccw) ?? null;
+    const flipped = candidates.find(c => !c.ccw) ?? null;
+    let chosen;
+    if (flip) {
+        chosen = flipped ?? primary;
+    }
+    else {
+        chosen = primary ?? flipped;
+    }
+    const edge = buildArcEdge(plane, chosen);
+    return { edges: [edge], endTangent: chosen.endTangent };
+}
+function extractLineTarget(plane, target) {
+    const oc = getOC();
+    const shape = target.shape;
+    if (!(shape instanceof Edge)) {
+        throw new Error('tArc(target): target must be a line edge');
+    }
+    const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+    const type = adaptor.GetType();
+    if (type !== oc.GeomAbs_CurveType.GeomAbs_Line) {
+        adaptor.delete();
+        throw new Error('tArc(target): only line targets are supported');
+    }
+    adaptor.delete();
+    const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+    const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+    const diff = end.subtract(start);
+    const len = diff.length();
+    if (len < EPS) {
+        throw new Error('tArc(target): target line has zero length');
+    }
+    return {
+        pointOnLine: start,
+        direction: diff.multiplyScalar(1 / len)
+    };
+}
+function buildCandidate(P, Nx, Ny, r, target) {
+    const Ox = P.x + r * Nx;
+    const Oy = P.y + r * Ny;
+    const dx = target.direction.x;
+    const dy = target.direction.y;
+    const t = (Ox - target.pointOnLine.x) * dx + (Oy - target.pointOnLine.y) * dy;
+    const Qx = target.pointOnLine.x + t * dx;
+    const Qy = target.pointOnLine.y + t * dy;
+    const radius = Math.abs(r);
+    const ccw = r > 0;
+    const endAngle = Math.atan2(Qy - Oy, Qx - Ox);
+    const sign = ccw ? 1 : -1;
+    const endTangent = new Point2D(sign * (-Math.sin(endAngle)), sign * Math.cos(endAngle));
+    return {
+        center: new Point2D(Ox, Oy),
+        radius,
+        ccw,
+        startPoint: P,
+        endPoint: new Point2D(Qx, Qy),
+        endAngle,
+        endTangent
+    };
+}
+function buildArcEdge(plane, c) {
+    const normal = c.ccw ? plane.normal : plane.normal.negate();
+    const center = plane.localToWorld(c.center);
+    const start = plane.localToWorld(c.startPoint);
+    const end = plane.localToWorld(c.endPoint);
+    const arc = Geometry.makeArc(center, c.radius, normal, start, end);
+    return Geometry.makeEdgeFromCurve(arc);
+}

package/lib/dist/oc/constraints/geometric/tangent-arc-radius-to-object.d.ts

@@ -0,0 +1,8 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { Point2D } from "../../../math/point.js";
+export declare function solveTangentArcRadiusToObject(plane: Plane, startPoint: Point2D, startTangent: Point2D, signedRadius: number, target: QualifiedShape): {
+    edges: Edge[];
+    endTangent: Point2D | null;
+};

package/lib/dist/oc/constraints/geometric/tangent-arc-radius-to-object.js

@@ -0,0 +1,161 @@
+import { Edge } from "../../../common/edge.js";
+import { Point2D } from "../../../math/point.js";
+import { Convert } from "../../convert.js";
+import { Geometry } from "../../geometry.js";
+import { getOC } from "../../init.js";
+const EPS = 1e-10;
+export function solveTangentArcRadiusToObject(plane, startPoint, startTangent, signedRadius, target) {
+    if (Math.abs(signedRadius) < EPS) {
+        throw new Error('tArc(radius, target): radius must be non-zero');
+    }
+    const tlen = startTangent.length();
+    if (tlen < EPS) {
+        throw new Error('tArc(radius, target): start tangent has zero magnitude');
+    }
+    const Tx = startTangent.x / tlen;
+    const Ty = startTangent.y / tlen;
+    // N̂: 90° CCW from T̂. Signed radius > 0 puts center on +N̂ (left) → CCW arc.
+    const Nx = -Ty;
+    const Ny = Tx;
+    const Ox = startPoint.x + signedRadius * Nx;
+    const Oy = startPoint.y + signedRadius * Ny;
+    const center = new Point2D(Ox, Oy);
+    const radius = Math.abs(signedRadius);
+    const ccw = signedRadius > 0;
+    const targetGeom = extractTargetGeometry(plane, target);
+    const intersections = findIntersections(center, radius, targetGeom);
+    if (intersections.length === 0) {
+        throw new Error('tArc(radius, target): arc circle does not intersect target');
+    }
+    const startAngle = Math.atan2(startPoint.y - Oy, startPoint.x - Ox);
+    let best = null;
+    for (const Q of intersections) {
+        const endAngle = Math.atan2(Q.y - Oy, Q.x - Ox);
+        let sweep = endAngle - startAngle;
+        if (ccw) {
+            if (sweep < 0) {
+                sweep += 2 * Math.PI;
+            }
+        }
+        else {
+            if (sweep > 0) {
+                sweep -= 2 * Math.PI;
+            }
+        }
+        // Skip degenerate "no-sweep" intersections (start point itself on target).
+        if (Math.abs(sweep) < EPS) {
+            continue;
+        }
+        if (!best || Math.abs(sweep) < Math.abs(best.sweep)) {
+            best = { endPoint: Q, sweep, endAngle };
+        }
+    }
+    if (!best) {
+        throw new Error('tArc(radius, target): no intersection reachable in the arc direction');
+    }
+    const normal = ccw ? plane.normal : plane.normal.negate();
+    const worldCenter = plane.localToWorld(center);
+    const worldStart = plane.localToWorld(startPoint);
+    const worldEnd = plane.localToWorld(best.endPoint);
+    const arc = Geometry.makeArc(worldCenter, radius, normal, worldStart, worldEnd);
+    const edge = Geometry.makeEdgeFromCurve(arc);
+    const sign = ccw ? 1 : -1;
+    const endTangent = new Point2D(sign * (-Math.sin(best.endAngle)), sign * Math.cos(best.endAngle));
+    return { edges: [edge], endTangent };
+}
+function extractTargetGeometry(plane, target) {
+    const oc = getOC();
+    const shape = target.shape;
+    if (!(shape instanceof Edge)) {
+        throw new Error('tArc(radius, target): target must be a line, circle, or arc edge');
+    }
+    const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+    const type = adaptor.GetType();
+    if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+        adaptor.delete();
+        const start = plane.worldToLocal(shape.getFirstVertex().toPoint());
+        const end = plane.worldToLocal(shape.getLastVertex().toPoint());
+        const diff = end.subtract(start);
+        const len = diff.length();
+        if (len < EPS) {
+            throw new Error('tArc(radius, target): target line has zero length');
+        }
+        return {
+            type: 'line',
+            pointOnLine: start,
+            direction: diff.multiplyScalar(1 / len)
+        };
+    }
+    if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+        const circle = adaptor.Circle();
+        const r = circle.Radius();
+        const cWorld = Convert.toPoint(circle.Location());
+        adaptor.delete();
+        return {
+            type: 'circle',
+            center: plane.worldToLocal(cWorld),
+            radius: r
+        };
+    }
+    adaptor.delete();
+    throw new Error('tArc(radius, target): target must be a line, circle, or arc');
+}
+function findIntersections(center, radius, target) {
+    if (target.type === 'line') {
+        return lineCircleIntersections(center, radius, target.pointOnLine, target.direction);
+    }
+    return circleCircleIntersections(center, radius, target.center, target.radius);
+}
+function lineCircleIntersections(O, radius, Q_L, d_L) {
+    // Line unit normal (rotate direction +90° CCW).
+    const nx = -d_L.y;
+    const ny = d_L.x;
+    const d_OL = (O.x - Q_L.x) * nx + (O.y - Q_L.y) * ny;
+    const absD = Math.abs(d_OL);
+    if (absD > radius + EPS) {
+        return [];
+    }
+    // Foot of perpendicular from O onto the line.
+    const Fx = O.x - d_OL * nx;
+    const Fy = O.y - d_OL * ny;
+    const inside = Math.max(radius * radius - d_OL * d_OL, 0);
+    const h = Math.sqrt(inside);
+    if (h < EPS) {
+        return [new Point2D(Fx, Fy)];
+    }
+    return [
+        new Point2D(Fx + h * d_L.x, Fy + h * d_L.y),
+        new Point2D(Fx - h * d_L.x, Fy - h * d_L.y)
+    ];
+}
+function circleCircleIntersections(O, r1, Cc, r2) {
+    const dx = Cc.x - O.x;
+    const dy = Cc.y - O.y;
+    const d2 = dx * dx + dy * dy;
+    const d = Math.sqrt(d2);
+    if (d < EPS) {
+        return [];
+    }
+    if (d > r1 + r2 + EPS) {
+        return [];
+    }
+    if (d < Math.abs(r1 - r2) - EPS) {
+        return [];
+    }
+    const a = (d2 + r1 * r1 - r2 * r2) / (2 * d);
+    const inside = Math.max(r1 * r1 - a * a, 0);
+    const h = Math.sqrt(inside);
+    // Midpoint M = O + (a/d) * (Cc - O).
+    const Mx = O.x + (a / d) * dx;
+    const My = O.y + (a / d) * dy;
+    if (h < EPS) {
+        return [new Point2D(Mx, My)];
+    }
+    // Perpendicular (unit) to (Cc - O).
+    const px = -dy / d;
+    const py = dx / d;
+    return [
+        new Point2D(Mx + h * px, My + h * py),
+        new Point2D(Mx - h * px, My - h * py)
+    ];
+}

package/lib/dist/oc/mesh.d.ts

@@ -7,6 +7,11 @@ export interface MeshData {
     indices: number[];
     count?: number;
 }
+export interface MeshConfig {
+    linDefl: number;
+    angDefl: number;
+}
+export declare const DEFAULT_MESH_CONFIG: MeshConfig;
 export interface EnsureTriangulatedOptions {
     linDefl?: number;
     angDefl?: number;
@@ -15,15 +20,15 @@ export interface EnsureTriangulatedOptions {
     checkFreeEdges?: boolean;
 }
 export declare class Mesh {
-    static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
-    static discretizeEdge(edge: Shape): MeshData;
+    static triangulateFace(face: Face, vertexOffset?: number, opts?: EnsureTriangulatedOptions): MeshData | null;
+    static discretizeEdge(edge: Shape, opts?: EnsureTriangulatedOptions): MeshData;
     /**
      * 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: TopoDS_Shape, opts?: EnsureTriangulatedOptions): boolean;
-    static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number, opts?: EnsureTriangulatedOptions): MeshData | null;
     static extractFaceTriangulationRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
     /**
      * Reads the polyline stored for `edge` as a polygon-on-triangulation of
@@ -36,5 +41,5 @@ export declare class Mesh {
      * meshed face). Caller must have already run `ensureTriangulated` on the
      * edge or its parent wire.
      */
-    static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
+    static discretizeEdgeRaw(edge: TopoDS_Shape, opts?: EnsureTriangulatedOptions): MeshData;
 }

package/lib/dist/oc/mesh.js

@@ -1,15 +1,16 @@
 import { getOC } from "./init.js";
 import { Explorer } from "./explorer.js";
-// Flip to false to benchmark single-threaded meshing.
-const DEFAULT_LIN_DEFLECTION = 0.1;
-const DEFAULT_ANG_DEFLECTION = 0.5;
+export const DEFAULT_MESH_CONFIG = {
+    linDefl: 0.1,
+    angDefl: 0.5,
+};
 export class Mesh {
     // Wrapper methods (public API for external callers)
-    static triangulateFace(face, vertexOffset = 0) {
-        return Mesh.triangulateFaceRaw(face.getShape(), vertexOffset);
+    static triangulateFace(face, vertexOffset = 0, opts) {
+        return Mesh.triangulateFaceRaw(face.getShape(), vertexOffset, opts);
     }
-    static discretizeEdge(edge) {
-        return Mesh.discretizeEdgeRaw(edge.getShape());
+    static discretizeEdge(edge, opts) {
+        return Mesh.discretizeEdgeRaw(edge.getShape(), opts);
     }
     /**
      * Triangulates `shape` only if it doesn't already have an up-to-date
@@ -18,8 +19,8 @@ export class Mesh {
      */
     static ensureTriangulated(shape, opts = {}) {
         const oc = getOC();
-        const linDefl = opts.linDefl ?? DEFAULT_LIN_DEFLECTION;
-        const angDefl = opts.angDefl ?? DEFAULT_ANG_DEFLECTION;
+        const linDefl = opts.linDefl ?? DEFAULT_MESH_CONFIG.linDefl;
+        const angDefl = opts.angDefl ?? DEFAULT_MESH_CONFIG.angDefl;
         const relative = opts.relative ?? false;
         const checkFreeEdges = opts.checkFreeEdges ?? true;
         if (oc.BRepTools.Triangulation(shape, linDefl, checkFreeEdges)) {
@@ -31,9 +32,9 @@ export class Mesh {
         return true;
     }
     // Raw methods (for oc-internal use)
-    static triangulateFaceRaw(face, vertexOffset = 0) {
+    static triangulateFaceRaw(face, vertexOffset = 0, opts) {
         try {
-            Mesh.ensureTriangulated(face);
+            Mesh.ensureTriangulated(face, opts);
         }
         catch (e) {
             console.error("Face mesh failed", e);
@@ -151,14 +152,14 @@ export class Mesh {
      * meshed face). Caller must have already run `ensureTriangulated` on the
      * edge or its parent wire.
      */
-    static discretizeEdgeRaw(edge) {
+    static discretizeEdgeRaw(edge, opts) {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
         if (oc.BRep_Tool.Degenerated(ocEdge)) {
             ocEdge.delete();
             return { vertices: [], normals: [], indices: [] };
         }
-        Mesh.ensureTriangulated(edge);
+        Mesh.ensureTriangulated(edge, opts);
         const loc = new oc.TopLoc_Location();
         const polyHandle = oc.BRep_Tool.Polygon3D(ocEdge, loc);
         if (polyHandle.IsNull()) {

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

@@ -1,5 +1,6 @@
 import { Shape } from "../common/shape.js";
 import { Face } from "../common/face.js";
+import { ShellJoinType } from "../core/interfaces.js";
 export declare class ShellOps {
-    static makeThickSolid(solid: Shape, faces: Face[], thickness: number): Shape;
+    static makeThickSolid(solid: Shape, faces: Face[], thickness: number, joinType?: ShellJoinType): Shape;
 }

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

@@ -3,15 +3,18 @@ import { ShapeOps } from "./shape-ops.js";
 import { ShapeFactory } from "../common/shape-factory.js";
 import { ColorTransfer } from "./color-transfer.js";
 export class ShellOps {
-    static makeThickSolid(solid, faces, thickness) {
+    static makeThickSolid(solid, faces, thickness, joinType = 'arc') {
         const oc = getOC();
         const listOfFaces = new oc.TopTools_ListOfShape();
         for (const f of faces) {
             listOfFaces.Append(f.getShape());
         }
+        const ocJoinType = joinType === 'intersection' ? oc.GeomAbs_JoinType.GeomAbs_Intersection
+            : joinType === 'tangent' ? oc.GeomAbs_JoinType.GeomAbs_Tangent
+                : oc.GeomAbs_JoinType.GeomAbs_Arc;
         const maker = new oc.BRepOffsetAPI_MakeThickSolid();
         const progress = new oc.Message_ProgressRange();
-        maker.MakeThickSolidByJoin(oc.TopoDS.Solid(solid.getShape()), listOfFaces, thickness, oc.Precision.Confusion(), oc.BRepOffset_Mode.BRepOffset_Skin, false, false, oc.GeomAbs_JoinType.GeomAbs_Arc, false, progress);
+        maker.MakeThickSolidByJoin(oc.TopoDS.Solid(solid.getShape()), listOfFaces, thickness, oc.Precision.Confusion(), oc.BRepOffset_Mode.BRepOffset_Skin, false, false, ocJoinType, false, progress);
         progress.delete();
         if (!maker.IsDone()) {
             maker.delete();

package/lib/dist/rendering/mesh-builder.d.ts

@@ -1,5 +1,8 @@
 import { Shape } from "../common/shape.js";
 import { SceneObjectMesh } from "./scene.js";
+import type { MeshConfig } from "../oc/mesh.js";
 export declare class MeshBuilder {
+    private readonly meshConfig;
+    constructor(meshConfig: MeshConfig);
     build(shapeObj: Shape): SceneObjectMesh[];
 }

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

@@ -4,20 +4,24 @@ import { renderFace } from "./render-face.js";
 import { renderWire } from "./render-wire.js";
 import { renderEdge } from "./render-edge.js";
 export class MeshBuilder {
+    meshConfig;
+    constructor(meshConfig) {
+        this.meshConfig = meshConfig;
+    }
     build(shapeObj) {
         const shape = shapeObj.getShape();
         let result = null;
         if (Explorer.isSolid(shape)) {
-            result = renderSolid(shapeObj);
+            result = renderSolid(shapeObj, this.meshConfig);
         }
         else if (Explorer.isFace(shape)) {
-            result = renderFace(shapeObj);
+            result = renderFace(shapeObj, 0, this.meshConfig);
         }
         else if (Explorer.isWire(shape)) {
-            result = renderWire(shapeObj);
+            result = renderWire(shapeObj, this.meshConfig);
         }
         else if (Explorer.isEdge(shape)) {
-            result = renderEdge(shapeObj);
+            result = renderEdge(shapeObj, this.meshConfig);
         }
         else if (Explorer.isCompound(shape)) {
             console.warn("Compound shapes are not supported yet.");

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

@@ -1,3 +1,4 @@
 import { Shape } from "../common/shape.js";
+import type { MeshConfig } from "../oc/mesh.js";
 import type { SceneObjectMesh } from "./scene.js";
-export declare function renderEdge(edgeObj: Shape): SceneObjectMesh;
+export declare function renderEdge(edgeObj: Shape, meshConfig?: MeshConfig): SceneObjectMesh;

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

@@ -1,4 +1,4 @@
 import { Mesh } from "../oc/mesh.js";
-export function renderEdge(edgeObj) {
-    return Mesh.discretizeEdge(edgeObj);
+export function renderEdge(edgeObj, meshConfig) {
+    return Mesh.discretizeEdge(edgeObj, meshConfig);
 }

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

@@ -1,2 +1,3 @@
 import { Shape } from "../common/shape.js";
-export declare function renderFace(faceObj: Shape, vertexOffset?: number): import("../oc/mesh.js").MeshData;
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderFace(faceObj: Shape, vertexOffset?: number, meshConfig?: MeshConfig): import("../oc/mesh.js").MeshData;

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

@@ -1,5 +1,5 @@
 import { Mesh } from "../oc/mesh.js";
-export function renderFace(faceObj, vertexOffset = 0) {
+export function renderFace(faceObj, vertexOffset = 0, meshConfig) {
     const face = faceObj.getShape();
-    return Mesh.triangulateFaceRaw(face, vertexOffset);
+    return Mesh.triangulateFaceRaw(face, vertexOffset, meshConfig);
 }

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

@@ -1,3 +1,4 @@
 import { Shape } from "../common/shape.js";
 import { SceneObjectMesh } from "./scene.js";
-export declare function renderSolid(shapeObj: Shape): SceneObjectMesh[];
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderSolid(shapeObj: Shape, meshConfig?: MeshConfig): SceneObjectMesh[];

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

@@ -1,8 +1,8 @@
 import { Explorer } from "../oc/explorer.js";
 import { Mesh } from "../oc/mesh.js";
 import { getOC } from "../oc/init.js";
-export function renderSolid(shapeObj) {
-    Mesh.ensureTriangulated(shapeObj.getShape());
+export function renderSolid(shapeObj, meshConfig) {
+    Mesh.ensureTriangulated(shapeObj.getShape(), meshConfig);
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];

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

@@ -1,5 +1,6 @@
 import { Shape } from "../common/shape.js";
-export declare function renderWire(shapeObj: Shape): {
+import type { MeshConfig } from "../oc/mesh.js";
+export declare function renderWire(shapeObj: Shape, meshConfig?: MeshConfig): {
     vertices: number[];
     normals: number[];
     indices: number[];

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

@@ -2,9 +2,9 @@ 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) {
+export function renderWire(shapeObj, meshConfig) {
     const shape = shapeObj.getShape();
-    Mesh.ensureTriangulated(shape);
+    Mesh.ensureTriangulated(shape, meshConfig);
     const edges = Explorer.findShapes(shape, Explorer.getOcShapeType("edge"));
     const allVertices = [];
     const allNormals = [];

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

@@ -1,6 +1,9 @@
 import { Scene } from "./scene.js";
+import type { MeshConfig } from "../oc/mesh.js";
 export declare class SceneRenderer {
+    private readonly meshConfig;
     private readonly meshBuilder;
+    constructor(meshConfig: MeshConfig);
     render(scene: Scene): Scene;
     renderRollback(scene: Scene, rollbackIndex: number): Scene;
     private batchTriangulate;