fluidcad 0.0.2

package/lib/dist/features/revolve.js

@@ -0,0 +1,150 @@
+import { rad } from "../helpers/math-helpers.js";
+import { Solid } from "../common/shapes.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { ExtrudeOps } from "../oc/extrude-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { FaceOps } from "../oc/face-ops.js";
+export class Revolve extends ExtrudeBase {
+    axis;
+    angle;
+    constructor(axis, angle, extrudable) {
+        super(extrudable);
+        this.axis = axis;
+        this.angle = angle;
+    }
+    build(context) {
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        const solids = [];
+        const allStartFaces = [];
+        const allEndFaces = [];
+        const allSideFaces = [];
+        const allInternalFaces = [];
+        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        const { result: fusedFaces } = BooleanOps.fuseFaces(faces);
+        const axis = this.axis.getAxis();
+        const isFullRevolution = Math.abs(this.angle) >= 360;
+        for (const face of fusedFaces) {
+            const solid = ExtrudeOps.makeRevol(face, axis, rad(this.angle));
+            // Collect inner wire edges for internal face detection
+            const innerWireEdges = [];
+            const wires = face.getWires();
+            for (const wire of wires) {
+                if (!wire.isCW(plane.normal)) {
+                    for (const edge of wire.getEdges()) {
+                        innerWireEdges.push(edge);
+                    }
+                }
+            }
+            let resultSolid;
+            if (this._symmetric) {
+                const rotated = ShapeOps.rotateShape(solid.getShape(), axis, -rad(this.angle) / 2);
+                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(rotated));
+            }
+            else {
+                resultSolid = Solid.fromTopoDSSolid(Explorer.toSolid(solid.getShape()));
+            }
+            solids.push(resultSolid);
+            // Classify faces of the revolved solid
+            const solidFaces = Explorer.findFacesWrapped(resultSolid);
+            for (const f of solidFaces) {
+                const isOnSourcePlane = FaceOps.faceOnPlaneWrapped(f, plane);
+                if (isOnSourcePlane && !isFullRevolution) {
+                    allStartFaces.push(f);
+                }
+                else if (!isOnSourcePlane) {
+                    if (innerWireEdges.length > 0) {
+                        const faceEdges = f.getEdges();
+                        const isInternal = faceEdges.some(fe => innerWireEdges.some(iwe => fe.getShape().IsPartner(iwe.getShape())));
+                        if (isInternal) {
+                            allInternalFaces.push(f);
+                            continue;
+                        }
+                    }
+                    allSideFaces.push(f);
+                }
+            }
+        }
+        // For partial revolves with symmetric, classify start/end by plane offset
+        if (!isFullRevolution && allStartFaces.length > 1) {
+            const half = Math.floor(allStartFaces.length / 2);
+            const startSlice = allStartFaces.splice(0, half);
+            const endSlice = allStartFaces.splice(0);
+            allStartFaces.length = 0;
+            allStartFaces.push(...startSlice);
+            allEndFaces.push(...endSlice);
+        }
+        this.setState('start-faces', allStartFaces);
+        this.setState('end-faces', allEndFaces);
+        this.setState('side-faces', allSideFaces);
+        this.setState('internal-faces', allInternalFaces);
+        this.extrudable.removeShapes(this);
+        this.axis.removeShapes(this);
+        if (this._operationMode === 'remove') {
+            const scope = this.resolveFusionScope(context.getSceneObjects());
+            cutWithSceneObjects(scope, solids, plane, 0, this);
+            return;
+        }
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        if (sceneObjects.length === 0) {
+            this.addShapes(solids);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (modifiedShape.object) {
+                modifiedShape.object.removeShape(modifiedShape.shape, this);
+            }
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    getDependencies() {
+        return this.extrudable ? [this.extrudable] : [];
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new Revolve(this.axis, this.angle, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof Revolve)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (!this.axis.compareTo(other.axis)) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "revolve";
+    }
+    serialize() {
+        return {
+            angle: this.angle,
+            axis: this.axis.serialize(),
+            operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            symmetric: this._symmetric || undefined,
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export declare class Rotate extends SceneObject {
+    axis: AxisObjectBase;
+    angle: number;
+    private copy;
+    private _targetObjects;
+    constructor(axis: AxisObjectBase, angle: number, copy?: boolean, ...targets: SceneObject[]);
+    get targetObjects(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: Rotate): boolean;
+    getType(): string;
+    serialize(): {
+        angle: number;
+    };
+}

package/lib/dist/features/rotate.js

@@ -0,0 +1,89 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Rotate extends SceneObject {
+    axis;
+    angle;
+    copy;
+    _targetObjects = null;
+    constructor(axis, angle, copy = false, ...targets) {
+        super();
+        this.axis = axis;
+        this.angle = angle;
+        this.copy = copy;
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let objects;
+        let targetObjects = this.targetObjects;
+        let parent = null;
+        if (this.parentId) {
+            parent = this.getParent();
+            objects = parent.getPreviousSiblings(this);
+        }
+        else {
+            objects = context.getSceneObjects();
+        }
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            targetObjects = objects.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            targetObjects = objects;
+        }
+        this.axis.removeShapes(this);
+        const axis = this.axis.getAxis();
+        const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(this.angle));
+        for (const obj of targetObjects) {
+            const shapes = obj.getShapes();
+            for (const shape of shapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                this.addShape(transformed);
+                if (!this.copy) {
+                    obj.removeShape(shape, this);
+                }
+            }
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof Rotate)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.copy !== other.copy) {
+            return false;
+        }
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        if (this.axis) {
+            if (!this.axis.compareTo(other.axis)) {
+                return false;
+            }
+        }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (thisTargetObjects[i] !== otherTargetObjects[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "rotate";
+    }
+    serialize() {
+        return {
+            angle: this.angle
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Rotate2D extends GeometrySceneObject {
+    angle: number;
+    private copy;
+    private _targetObjects;
+    constructor(angle: number, copy?: boolean, ...targets: SceneObject[]);
+    get targetObjects(): SceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: Rotate2D): boolean;
+    getType(): string;
+    serialize(): {
+        angle: number;
+    };
+}

package/lib/dist/features/rotate2d.js

@@ -0,0 +1,83 @@
+import { Axis } from "../math/axis.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export class Rotate2D extends GeometrySceneObject {
+    angle;
+    copy;
+    _targetObjects = null;
+    constructor(angle, copy = false, ...targets) {
+        super();
+        this.angle = angle;
+        this.copy = copy;
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let objects;
+        let targetObjects = this.targetObjects;
+        let axis;
+        objects = this.sketch.getPreviousSiblings(this);
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            targetObjects = objects.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            targetObjects = objects;
+        }
+        const plane = this.sketch.getPlane();
+        const currentPosition = plane.localToWorld(this.sketch.getPositionAt(this));
+        axis = new Axis(currentPosition, plane.zAxis.direction);
+        const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(this.angle));
+        for (const obj of targetObjects) {
+            const shapes = obj.getShapes();
+            for (const shape of shapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                this.addShape(transformed);
+                if (!this.copy) {
+                    obj.removeShape(shape, this);
+                }
+            }
+        }
+        const lastTangent = this.sketch.getTangentAt(this);
+        if (lastTangent) {
+            const transformedTangent = lastTangent.transform(matrix);
+            this.setTangent(transformedTangent);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof Rotate2D)) {
+            return false;
+        }
+        if (this.copy !== other.copy) {
+            return false;
+        }
+        if (this.angle !== other.angle) {
+            return false;
+        }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "rotate";
+    }
+    serialize() {
+        return {
+            angle: this.angle
+        };
+    }
+}

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

@@ -0,0 +1,26 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { FilterBuilderBase } from "../filters/filter-builder-base.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { ISelect } from "../core/interfaces.js";
+import { Shape } from "../common/shape.js";
+import { ShapeType } from "../common/shape-type.js";
+export declare class SelectSceneObject extends SceneObject implements ISelect {
+    private filters;
+    private constraintObject?;
+    private type;
+    private shapes;
+    constructor(filters: FilterBuilderBase<Shape>[], constraintObject?: SceneObject);
+    build(context: BuildSceneObjectContext): void;
+    private getAllShapes;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    transform(matrix: Matrix4): SelectSceneObject;
+    applyFilters(shapes: Shape[], filters: FilterBuilderBase<Shape>[]): Shape[];
+    compareTo(other: SelectSceneObject): boolean;
+    shapeType(): string;
+    getType(): string;
+    serialize(): {
+        selectionLength: number;
+        type: ShapeType;
+    };
+}

package/lib/dist/features/select.js

@@ -0,0 +1,113 @@
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { ShapeFilter } from "../filters/filter.js";
+import { SceneObject } from "../common/scene-object.js";
+export class SelectSceneObject extends SceneObject {
+    filters;
+    constraintObject;
+    type;
+    shapes = [];
+    constructor(filters, constraintObject) {
+        super();
+        this.filters = filters;
+        this.constraintObject = constraintObject;
+        if (filters.every(f => f instanceof FaceFilterBuilder)) {
+            this.type = "face";
+        }
+        else {
+            this.type = "edge";
+        }
+    }
+    build(context) {
+        const parent = this.getParent();
+        const transform = context.getTransform();
+        let filters = this.filters;
+        let sceneObjects = context.getSceneObjects();
+        let excludedObjects = [];
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+            if (!this.constraintObject && parent) {
+                const snapshot = parent.getSnapshot();
+                excludedObjects = snapshot ? Array.from(snapshot.values()).flat() : [];
+                sceneObjects = context.getSceneObjectsFromTo(parent, this);
+            }
+        }
+        const allShapes = this.constraintObject ? this.constraintObject.getShapes() : this.getAllShapes(sceneObjects, excludedObjects);
+        const filteredShapes = this.applyFilters(allShapes, filters);
+        console.log(`SelectSceneObject: shapes after filtering: ${filteredShapes[0]}`);
+        this.addShapes(filteredShapes);
+    }
+    getAllShapes(scope, exludedShapes) {
+        const scopeShapes = scope.flatMap(obj => obj.getShapes({}, 'solid').map(s => s.getSubShapes(this.type)).flat());
+        exludedShapes = exludedShapes.flatMap(s => s.getSubShapes(this.type));
+        const finalShapes = scopeShapes.filter(shape => !exludedShapes.some(exShape => exShape.isSame(shape)));
+        console.log('=== Scope Objects:', scope.length, ' Shapes:', scopeShapes.length);
+        console.log('=== Excluded Shapes:', exludedShapes.length);
+        console.log('=== Final Shapes after exclusion:', finalShapes.length);
+        let allShapes = [];
+        for (const shape of finalShapes) {
+            allShapes.push(shape);
+        }
+        console.log('SelectSceneObject: total shapes collected for filtering:', allShapes.length);
+        return allShapes;
+    }
+    getDependencies() {
+        return this.constraintObject ? [this.constraintObject] : [];
+    }
+    createCopy(remap) {
+        const remappedConstraint = this.constraintObject
+            ? (remap.get(this.constraintObject) || this.constraintObject)
+            : undefined;
+        return new SelectSceneObject(this.filters, remappedConstraint);
+    }
+    transform(matrix) {
+        const mirroredFilters = this.filters.map(f => f.transform(matrix));
+        console.log('SelectSceneObject: transform applied to selection filters.', mirroredFilters);
+        return new SelectSceneObject(mirroredFilters, this.constraintObject);
+    }
+    applyFilters(shapes, filters) {
+        const shapeFilter = new ShapeFilter(shapes, ...filters);
+        return shapeFilter.apply();
+    }
+    compareTo(other) {
+        if (!(other instanceof SelectSceneObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.type !== other.type) {
+            return false;
+        }
+        const thisHasConstraint = !!this.constraintObject;
+        const otherHasConstraint = !!other.constraintObject;
+        if (thisHasConstraint !== otherHasConstraint) {
+            return false;
+        }
+        if (thisHasConstraint && otherHasConstraint) {
+            if (!this.constraintObject.compareTo(other.constraintObject)) {
+                return false;
+            }
+        }
+        if (this.filters.length !== other.filters.length) {
+            return false;
+        }
+        for (let i = 0; i < this.filters.length; i++) {
+            if (!this.filters[i].equals(other.filters[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    shapeType() {
+        return this.type;
+    }
+    getType() {
+        return "select";
+    }
+    serialize() {
+        return {
+            selectionLength: this.shapes.length,
+            type: this.type
+        };
+    }
+}

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

@@ -0,0 +1,24 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { SelectSceneObject } from "./select.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { IShell } from "../core/interfaces.js";
+export declare class Shell extends SceneObject implements IShell {
+    private thickness;
+    private _faceSelections;
+    constructor(thickness: number, faceSelections?: SelectSceneObject[]);
+    get faceSelections(): SelectSceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    internalFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
+    internalEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
+    private buildSuffix;
+    private resolveEdges;
+    private resolveFaces;
+    compareTo(other: SceneObject): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    getType(): string;
+    serialize(): {
+        thickness: number;
+    };
+}