fluidcad 0.0.20 → 0.0.22

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

@@ -0,0 +1,51 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { ShapeOps } from "./shape-ops.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Plane } from "../math/plane.js";
+import { Point } from "../math/point.js";
+export class DraftOps {
+    static applyDraft(solid, faceRaws, angle) {
+        const oc = getOC();
+        const solidRaw = solid.getShape();
+        const bbox = ShapeOps.getBoundingBox(solid);
+        const neutralPlane = new Plane(new Point(0, 0, bbox.minZ), new Vector3d(1, 0, 0), new Vector3d(0, 0, 1));
+        const [dir, disposeDir] = Convert.toGpDir(neutralPlane.normal);
+        const [pln, disposePln] = Convert.toGpPln(neutralPlane);
+        try {
+            const draftMaker = new oc.BRepOffsetAPI_DraftAngle(solidRaw);
+            let addedCount = 0;
+            const explorer = new oc.TopExp_Explorer(solidRaw, oc.TopAbs_ShapeEnum.TopAbs_FACE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+            while (explorer.More()) {
+                const currentShape = explorer.Current();
+                const isSelected = faceRaws.some(sel => sel.IsSame(currentShape));
+                if (isSelected) {
+                    const face = oc.TopoDS.Face(currentShape);
+                    draftMaker.Add(face, dir, -angle, pln, true);
+                    addedCount++;
+                }
+                explorer.Next();
+            }
+            explorer.delete();
+            if (addedCount === 0) {
+                draftMaker.delete();
+                return null;
+            }
+            const progress = new oc.Message_ProgressRange();
+            draftMaker.Build(progress);
+            progress.delete();
+            if (!draftMaker.IsDone()) {
+                draftMaker.delete();
+                throw new Error("Failed to apply draft angle.");
+            }
+            const result = draftMaker.Shape();
+            draftMaker.delete();
+            return ShapeFactory.fromShape(result);
+        }
+        finally {
+            disposeDir();
+            disposePln();
+        }
+    }
+}

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

@@ -10,6 +10,8 @@ export interface MeshData {
 export declare class Mesh {
     static triangulateFace(face: Face, vertexOffset?: number): MeshData | null;
     static discretizeEdge(edge: Shape): MeshData;
+    static premeshShape(shape: TopoDS_Shape): void;
     static triangulateFaceRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
+    static extractFaceTriangulationRaw(face: TopoDS_Face, vertexOffset?: number): MeshData | null;
     static discretizeEdgeRaw(edge: TopoDS_Shape): MeshData;
 }

package/lib/dist/oc/mesh.js

@@ -7,12 +7,14 @@ export class Mesh {
     static discretizeEdge(edge) {
         return Mesh.discretizeEdgeRaw(edge.getShape());
     }
+    static premeshShape(shape) {
+        const oc = getOC();
+        const inc = new oc.BRepMesh_IncrementalMesh(shape, 0.3, false, 0.3, true);
+        inc.delete();
+    }
     // Raw methods (for oc-internal use)
     static triangulateFaceRaw(face, vertexOffset = 0) {
         const oc = getOC();
-        const vertices = [];
-        const normals = [];
-        const indices = [];
         let inc;
         try {
             inc = new oc.BRepMesh_IncrementalMesh(face, 0.3, false, 0.3, true);
@@ -21,12 +23,19 @@ export class Mesh {
             console.error("Face mesh failed", e);
             return null;
         }
+        inc.delete();
+        return Mesh.extractFaceTriangulationRaw(face, vertexOffset);
+    }
+    static extractFaceTriangulationRaw(face, vertexOffset = 0) {
+        const oc = getOC();
+        const vertices = [];
+        const normals = [];
+        const indices = [];
         const aLocation = new oc.TopLoc_Location();
         const myT = oc.BRep_Tool.Triangulation(face, aLocation, 0);
         if (myT.IsNull()) {
             aLocation.delete();
-            inc.delete();
-            throw new Error("No triangulation for face");
+            return null;
         }
         const pc = new oc.Poly_Connect(myT);
         const triangulation = myT.get();
@@ -69,7 +78,6 @@ export class Mesh {
         triangles.delete();
         myT.delete();
         aLocation.delete();
-        inc.delete();
         return { vertices, normals, indices, count: nbNodes };
     }
     static discretizeEdgeRaw(edge) {

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

@@ -43,9 +43,12 @@ export class WireOps {
     static makeWireFromEdgesRaw(edges) {
         const oc = getOC();
         const wireMaker = new oc.BRepBuilderAPI_MakeWire();
+        const edgeList = new oc.TopTools_ListOfShape();
         for (const edge of edges) {
-            wireMaker.Add(oc.TopoDS.Edge(edge));
+            edgeList.Append(oc.TopoDS.Edge(edge));
         }
+        wireMaker.Add(edgeList);
+        edgeList.delete();
         if (!wireMaker.IsDone()) {
             wireMaker.delete();
             throw new Error("Failed to create wire from edges");

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

@@ -0,0 +1,3 @@
+import { SceneObjectMesh } from "./scene.js";
+import { Matrix4 } from "../math/matrix4.js";
+export declare function transformMeshes(meshes: SceneObjectMesh[], matrix: Matrix4): SceneObjectMesh[];

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

@@ -0,0 +1,22 @@
+export function transformMeshes(meshes, matrix) {
+    const m = matrix.elements;
+    return meshes.map(mesh => {
+        const srcV = mesh.vertices;
+        const srcN = mesh.normals;
+        const newV = new Array(srcV.length);
+        const newN = new Array(srcN.length);
+        for (let i = 0; i < srcV.length; i += 3) {
+            const x = srcV[i], y = srcV[i + 1], z = srcV[i + 2];
+            newV[i] = m[0] * x + m[4] * y + m[8] * z + m[12];
+            newV[i + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+            newV[i + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+        }
+        for (let i = 0; i < srcN.length; i += 3) {
+            const nx = srcN[i], ny = srcN[i + 1], nz = srcN[i + 2];
+            newN[i] = m[0] * nx + m[4] * ny + m[8] * nz;
+            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 };
+    });
+}

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

@@ -1,7 +1,8 @@
-import { renderFace } from "./render-face.js";
 import { renderEdge } from "./render-edge.js";
 import { Explorer } from "../oc/explorer.js";
+import { Mesh } from "../oc/mesh.js";
 export function renderSolid(shapeObj) {
+    Mesh.premeshShape(shapeObj.getShape());
     const facesMeshes = getFacesMesh(shapeObj);
     const edgesMesh = getEdgesMesh(shapeObj);
     return [...facesMeshes, ...edgesMesh];
@@ -25,7 +26,7 @@ function getFacesMesh(shapeObj) {
     for (let faceIdx = 0; faceIdx < faces.length; faceIdx++) {
         const face = faces[faceIdx];
         const color = shapeObj.getColor(face.getShape());
-        const faceResult = renderFace(face, 0);
+        const faceResult = Mesh.extractFaceTriangulationRaw(face.getShape(), 0);
         if (faceResult) {
             if (!groups.has(color)) {
                 groups.set(color, { vertices: [], normals: [], indices: [], faceMapping: [], vertexOffset: 0 });

package/lib/dist/rendering/render.js

@@ -2,6 +2,7 @@ import { MeshBuilder } from "./mesh-builder.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
+import { transformMeshes } from "./mesh-transform.js";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
@@ -12,7 +13,18 @@ function renderSceneObject(obj, scene, buildDurationMs) {
         for (const shape of sceneShapes) {
             let meshes = shape.getMeshes();
             if (!meshes) {
-                meshes = meshBuilder.build(shape);
+                const meshSource = shape.getMeshSource();
+                if (meshSource) {
+                    let sourceMeshes = meshSource.shape.getMeshes();
+                    if (!sourceMeshes) {
+                        sourceMeshes = meshBuilder.build(meshSource.shape);
+                        meshSource.shape.setMeshes(sourceMeshes);
+                    }
+                    meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                }
+                else {
+                    meshes = meshBuilder.build(shape);
+                }
                 shape.setMeshes(meshes);
             }
             const shapeType = shape.getType();
@@ -71,7 +83,18 @@ export function renderSceneRollback(scene, rollbackIndex) {
             for (const shape of sceneShapes) {
                 let meshes = shape.getMeshes();
                 if (!meshes) {
-                    meshes = meshBuilder.build(shape);
+                    const meshSource = shape.getMeshSource();
+                    if (meshSource) {
+                        let sourceMeshes = meshSource.shape.getMeshes();
+                        if (!sourceMeshes) {
+                            sourceMeshes = meshBuilder.build(meshSource.shape);
+                            meshSource.shape.setMeshes(sourceMeshes);
+                        }
+                        meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                    }
+                    else {
+                        meshes = meshBuilder.build(shape);
+                    }
                     shape.setMeshes(meshes);
                 }
                 renderedSceneShapes.push({
@@ -219,7 +242,5 @@ export function renderScene(scene) {
     for (const object of sceneObjects) {
         renderSceneObject(object, scene, buildDurations.get(object));
     }
-    const result = scene.getRenderedObjects();
-    console.table(result);
     return scene;
 }

package/lib/dist/tests/features/draft.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/draft.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import draft from "../../core/draft.js";
+import select from "../../core/select.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { face } from "../../filters/index.js";
+describe("draft", () => {
+    setupOC();
+    describe("draft with implicit selection", () => {
+        it("should apply draft to the last selected face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should change the bounding box when drafting a side face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // 5 deg draft over 80mm height: tan(5°) * 80 ≈ 7mm extension
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+        it("should change volume compared to original box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const props = ShapeProps.getProperties(solid.getShape());
+            const originalVolume = 100 * 100 * 80;
+            expect(Math.abs(props.volumeMm3 - originalVolume)).toBeGreaterThan(1000);
+        });
+    });
+    describe("draft with explicit selection", () => {
+        it("should apply draft using e.sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should apply draft using explicit select()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("draft angle effect", () => {
+        it("should produce larger extension with 10 degrees than 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(10);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(10°) * 80 ≈ 14.1mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(110);
+        });
+        it("should produce smaller extension with 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(3);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(3°) * 80 ≈ 4.2mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeLessThan(110);
+        });
+    });
+    describe("draft removes selection shapes", () => {
+        it("should remove the face selection after drafting", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            render();
+            expect(sel.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("draft on multiple faces", () => {
+        it("should draft all four side faces via sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // All four sides drafted — bounding box should extend in both X and Y
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+    });
+});