fluidcad 0.0.21 → 0.0.22

package/README.md

@@ -71,7 +71,7 @@ Re-apply modeling features based on matrix transformations. Move, rotate, or mir
 
 ```javascript
 sketch("xy", () => {
-    rect(200, 100).center()
+    rect(200, 100).centered()
 })
 
 const e1 = extrude(20)
@@ -155,7 +155,12 @@ Step-by-step tutorials from simple shapes to exam-level parts. [Browse all tutor
         <strong>CSWP Sample Exam</strong>
       </a>
     </td>
-    <td width="33%"></td>
+    <td align="center" width="33%">
+      <a href="https://fluidcad.io/docs/tutorials/hinge-bracket">
+        <img src="https://fluidcad.io/assets/images/hinge-bracket-final-137547b475db21736d78b5b13f8db48b.png" alt="Hinge Bracket" height="180" /><br />
+        <strong>Hinge Bracket</strong>
+      </a>
+    </td>
   </tr>
 </table>
 

package/lib/dist/common/shape.d.ts

@@ -1,6 +1,7 @@
 import type { TopoDS_Shape } from "occjs-wrapper";
 import { ShapeType } from "./shape-type.js";
 import { SceneObjectMesh } from "../rendering/scene.js";
+import { Matrix4 } from "../math/matrix4.js";
 export interface ShapeFilter {
     excludeMeta?: boolean;
     excludeGuide?: boolean;
@@ -17,6 +18,7 @@ export declare abstract class Shape<T extends TopoDS_Shape = TopoDS_Shape> {
         color: string;
     }>;
     private meshes;
+    private _meshSource;
     constructor(shape: T);
     abstract getType(): ShapeType;
     getShape(): T;
@@ -36,6 +38,11 @@ export declare abstract class Shape<T extends TopoDS_Shape = TopoDS_Shape> {
     isGuideShape(): boolean;
     getMeshes(): SceneObjectMesh[];
     setMeshes(meshes: SceneObjectMesh[]): void;
+    setMeshSource(source: Shape, matrix: Matrix4): void;
+    getMeshSource(): {
+        shape: Shape;
+        matrix: Matrix4;
+    } | null;
     setColor(face: TopoDS_Shape, color: string): void;
     getColor(face: TopoDS_Shape): string | undefined;
     hasColors(): boolean;

package/lib/dist/common/shape.js

@@ -8,6 +8,7 @@ export class Shape {
     id;
     colorMap = [];
     meshes;
+    _meshSource = null;
     constructor(shape) {
         this.shape = shape;
         this.id = randomUUID();
@@ -70,6 +71,12 @@ export class Shape {
     setMeshes(meshes) {
         this.meshes = meshes;
     }
+    setMeshSource(source, matrix) {
+        this._meshSource = { shape: source, matrix };
+    }
+    getMeshSource() {
+        return this._meshSource;
+    }
     setColor(face, color) {
         if (this.isEdge()) {
             throw new Error("Cannot set color on edge shape");

package/lib/dist/core/copy.js

@@ -16,7 +16,7 @@ function build(context) {
         const restObjects = args.slice(3);
         const objects = restObjects.length > 0
             ? restObjects
-            : [context.getSceneObjects().at(-1)];
+            : null;
         if (type === 'linear') {
             const axisArg = args[1];
             const axes = Array.isArray(axisArg)

package/lib/dist/core/draft.d.ts

@@ -0,0 +1,16 @@
+import { ISceneObject, IDraft } from "./interfaces.js";
+interface DraftFunction {
+    /**
+     * Applies a draft angle to the last selected faces.
+     * @param angle - The draft angle in degrees
+     */
+    (angle: number): IDraft;
+    /**
+     * Applies a draft angle to the given face selections.
+     * @param angle - The draft angle in degrees
+     * @param selections - The face selections to draft
+     */
+    (angle: number, ...selections: ISceneObject[]): IDraft;
+}
+declare const _default: DraftFunction;
+export default _default;

package/lib/dist/core/draft.js

@@ -0,0 +1,29 @@
+import { Draft } from "../features/draft.js";
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { rad } from "../helpers/math-helpers.js";
+function build(context) {
+    return function draft() {
+        const args = Array.from(arguments);
+        const selections = [];
+        while (args.length > 0 && args[args.length - 1] instanceof SceneObject) {
+            selections.unshift(args.pop());
+        }
+        if (selections.length === 0) {
+            const implicit = context.getLastSelection() || undefined;
+            if (implicit) {
+                selections.push(implicit);
+            }
+        }
+        const angleDeg = (args.length >= 1 && typeof args[0] === 'number')
+            ? args[0]
+            : 5;
+        for (const sel of selections) {
+            context.addSceneObject(sel);
+        }
+        const draft = new Draft(rad(angleDeg), selections);
+        context.addSceneObject(draft);
+        return draft;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export type { ISceneObject, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve } from "./interfaces.js";
+export type { ISceneObject, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as plane } from "./plane.js";
 export { default as sketch } from "./sketch.js";
@@ -23,11 +23,10 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as color } from "./color.js";
+export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";
 export { default as split } from "./split.js";
 export { default as trim } from "./trim.js";
 export { default as part } from "./part.js";
-export { default as use } from "./use.js";
-export type { PartHandle } from "./part.js";
 export * from "./2d/index.js";
 export { breakpoint } from "./breakpoint.js";

package/lib/dist/core/index.js

@@ -22,10 +22,10 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as color } from "./color.js";
+export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";
 export { default as split } from "./split.js";
 export { default as trim } from "./trim.js";
 export { default as part } from "./part.js";
-export { default as use } from "./use.js";
 export * from "./2d/index.js";
 export { breakpoint } from "./breakpoint.js";

package/lib/dist/core/interfaces.d.ts

@@ -562,6 +562,8 @@ export interface ISweep extends IFuseable {
      */
     capEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
 }
+export interface IDraft extends ISceneObject {
+}
 export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).

package/lib/dist/core/part.d.ts

@@ -1,7 +1,3 @@
-export type PartHandle<T = any> = {
-    __fluidcad_part: true;
-    name: string;
-    _callback: (options: T) => void;
-};
-declare function part<T = any>(name: string, callback: (options: T) => void): PartHandle<T>;
+import { ISceneObject } from "./interfaces.js";
+declare function part(name: string, callback: () => void): ISceneObject;
 export default part;

package/lib/dist/core/part.js

@@ -1,29 +1,19 @@
 import { captureSourceLocation } from "../index.js";
-import { getCurrentScene, getCurrentFile } from "../scene-manager.js";
+import { getCurrentScene } from "../scene-manager.js";
 import { Part } from "../features/part.js";
 function part(name, callback) {
-    const handle = {
-        __fluidcad_part: true,
-        name,
-        _callback: callback,
-    };
+    const scene = getCurrentScene();
+    if (!scene) {
+        throw new Error("part() must be called within a scene context");
+    }
     const sourceLocation = captureSourceLocation();
-    const currentFile = getCurrentFile();
-    const isDirectEdit = sourceLocation
-        && currentFile
-        && sourceLocation.filePath === currentFile;
-    if (isDirectEdit) {
-        const scene = getCurrentScene();
-        if (scene) {
-            const partObj = new Part(name);
-            if (sourceLocation) {
-                partObj.setSourceLocation(sourceLocation);
-            }
-            scene.startProgressiveContainer(partObj);
-            callback(undefined);
-            scene.endProgressiveContainer();
-        }
+    const partObj = new Part(name);
+    if (sourceLocation) {
+        partObj.setSourceLocation(sourceLocation);
     }
-    return handle;
+    scene.startProgressiveContainer(partObj);
+    callback();
+    scene.endProgressiveContainer();
+    return partObj;
 }
 export default part;

package/lib/dist/features/2d/sketch.d.ts

@@ -18,6 +18,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];
     getEdgesWithOwner(): Map<Edge, GeometrySceneObject>;
+    getAllEdges(): Edge[];
     getGeometriesWithOwner(): Map<Edge, GeometrySceneObject>;
     getGeometries(): Edge[];
     getDependencies(): SceneObject[];

package/lib/dist/features/2d/sketch.js

@@ -83,7 +83,7 @@ export class Sketch extends SceneObject {
         const source = this.getCloneSource();
         const transform = context?.getTransform();
         if (source instanceof Sketch && transform) {
-            const originalEdges = source.getEdges();
+            const originalEdges = source.getAllEdges();
             const transformedEdges = originalEdges.map(edge => ShapeOps.transform(edge, transform));
             this.setState('cloned-edges', transformedEdges);
         }
@@ -98,7 +98,24 @@ export class Sketch extends SceneObject {
     getEdgesWithOwner() {
         const children = this.getChildren();
         const result = new Map();
-        // get edges and filter out the ones that were removed by non-siblings
+        for (const child of children) {
+            const shapes = child.getShapes();
+            for (const shape of shapes) {
+                if (shape instanceof Edge) {
+                    result.set(shape, child);
+                }
+                else if (shape instanceof Wire) {
+                    for (const edge of shape.getEdges()) {
+                        result.set(edge, child);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    getAllEdges() {
+        const children = this.getChildren();
+        const result = [];
         for (const child of children) {
             const shapes = child.getAddedShapes();
             const removedShapes = child.getRemovedShapes();
@@ -111,11 +128,11 @@ export class Sketch extends SceneObject {
                     continue;
                 }
                 if (shape instanceof Edge) {
-                    result.set(shape, child);
+                    result.push(shape);
                 }
                 else if (shape instanceof Wire) {
                     for (const edge of shape.getEdges()) {
-                        result.set(edge, child);
+                        result.push(edge);
                     }
                 }
             }

package/lib/dist/features/copy-circular.js

@@ -34,6 +34,7 @@ export class CopyCircular extends SceneObject {
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-circular2d.js

@@ -41,6 +41,7 @@ export class CopyCircular2D extends GeometrySceneObject {
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-linear.js

@@ -34,6 +34,7 @@ export class CopyLinear extends SceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
+        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -46,23 +47,21 @@ export class CopyLinear extends SceneObject {
             positions = next;
         }
         for (const pos of positions) {
-            if (pos.every(idx => idx === 0))
+            if (pos.every((idx, a) => idx === centerIndices[a]))
                 continue;
             if (skip?.some(coord => coord.every((v, a) => v === pos[a]))) {
                 continue;
             }
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
-                const axisCount = counts[a];
-                const axisOffset = axisOffsets[a];
-                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
-                const distance = startOffset + axisOffset * pos[a];
+                const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

package/lib/dist/features/copy-linear2d.js

@@ -38,6 +38,7 @@ export class CopyLinear2D extends GeometrySceneObject {
             const axisCount = counts[a];
             return axisCount > 1 ? len / (axisCount - 1) : 0;
         });
+        const centerIndices = this.axes.map((_, a) => centered ? Math.floor(counts[a] / 2) : 0);
         // Build grid positions as cartesian product of per-axis indices (0..counts[a]-1)
         let positions = [[]];
         for (let a = 0; a < this.axes.length; a++) {
@@ -50,23 +51,21 @@ export class CopyLinear2D extends GeometrySceneObject {
             positions = next;
         }
         for (const pos of positions) {
-            if (pos.every(idx => idx === 0))
+            if (pos.every((idx, a) => idx === centerIndices[a]))
                 continue;
             if (skip?.some(coord => coord.every((v, a) => v === pos[a]))) {
                 continue;
             }
             let matrix = Matrix4.identity();
             for (let a = 0; a < this.axes.length; a++) {
-                const axisCount = counts[a];
-                const axisOffset = axisOffsets[a];
-                const startOffset = centered ? -(axisCount * axisOffset) / 2 : 0;
-                const distance = startOffset + axisOffset * pos[a];
+                const distance = (pos[a] - centerIndices[a]) * axisOffsets[a];
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
             for (const obj of objects) {
                 for (const shape of obj.getShapes()) {
                     const transformed = ShapeOps.transform(shape, matrix);
+                    transformed.setMeshSource(shape, matrix);
                     this.addShape(transformed);
                 }
             }

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

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { IDraft } from "../core/interfaces.js";
+export declare class Draft extends SceneObject implements IDraft {
+    private angle;
+    private _selections;
+    constructor(angle: number, selections: SceneObject[]);
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: SceneObject): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    getType(): string;
+    serialize(): {
+        angle: number;
+    };
+}

package/lib/dist/features/draft.js

@@ -0,0 +1,88 @@
+import { SceneObject } from "../common/scene-object.js";
+import { DraftOps } from "../oc/draft-ops.js";
+export class Draft extends SceneObject {
+    angle;
+    _selections = [];
+    constructor(angle, selections) {
+        super();
+        this.angle = angle;
+        this._selections = selections;
+    }
+    build(context) {
+        const shapeObjMap = new Map();
+        for (const obj of context.getSceneObjects()) {
+            if (obj.id === this.parentId) {
+                continue;
+            }
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                shapeObjMap.set(shape, obj);
+            }
+        }
+        if (!shapeObjMap.size) {
+            return;
+        }
+        const allFaceShapes = [];
+        for (const sel of this._selections) {
+            allFaceShapes.push(...sel.getShapes());
+        }
+        const selectionFaces = allFaceShapes;
+        const selectionFaceRaws = selectionFaces.map(f => f.getShape());
+        const newShapes = [];
+        const allTargetShapes = Array.from(shapeObjMap.keys());
+        for (const shape of allTargetShapes) {
+            try {
+                const result = DraftOps.applyDraft(shape, selectionFaceRaws, this.angle);
+                if (!result) {
+                    continue;
+                }
+                newShapes.push(result);
+                const originalObj = shapeObjMap.get(shape);
+                originalObj.removeShape(shape, this);
+            }
+            catch (e) {
+                newShapes.push(shape);
+                console.warn("Draft: Failed to apply draft angle.", e);
+            }
+        }
+        for (const sel of this._selections) {
+            sel.removeShapes(this);
+        }
+        this.addShapes(newShapes);
+    }
+    compareTo(other) {
+        if (!(other instanceof Draft)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (this._selections.length !== other._selections.length) {
+            return false;
+        }
+        for (let i = 0; i < this._selections.length; i++) {
+            if (!this._selections[i].compareTo(other._selections[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getDependencies() {
+        return [...this._selections];
+    }
+    createCopy(remap) {
+        const selections = this._selections.map(sel => remap.get(sel) || sel);
+        return new Draft(this.angle, selections);
+    }
+    getType() {
+        return 'draft';
+    }
+    serialize() {
+        return {
+            angle: this.angle
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+export declare class DraftOps {
+    static applyDraft(solid: Shape, faceRaws: TopoDS_Shape[], angle: number): Shape;
+}

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/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 });