fluidcad 0.0.2

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

@@ -0,0 +1,262 @@
+import { Point2D } from "../../math/point.js";
+import { Geometry } from "../../oc/geometry.js";
+import { LazySelectionSceneObject } from "../lazy-scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Rect extends ExtrudableGeometryBase {
+    width;
+    height;
+    _radius;
+    _center = false;
+    constructor(width, height, targetPlane = null) {
+        super(targetPlane);
+        this.width = width;
+        this.height = height;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.getParent().getPlane();
+        let start = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        console.log("Rect::build start:", start);
+        let end = new Point2D(start.x + this.width, start.y + this.height);
+        if (this._center === true) {
+            end = start;
+            start = start.translate(-this.width / 2, -this.height / 2);
+        }
+        else if (this._center === 'horizontal') {
+            end = start;
+            start = start.translate(-this.width / 2, 0);
+        }
+        else if (this._center === 'vertical') {
+            end = start;
+            start = start.translate(0, -this.height / 2);
+        }
+        let edges = [];
+        if (this._radius) {
+            edges = this.buildRoundedRect(start, plane);
+        }
+        else {
+            edges = this.buildSimpleRect(start, plane);
+        }
+        this.addShapes(edges);
+        if (this.sketch) {
+            this.setCurrentPosition(end);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    buildSimpleRect(start, plane) {
+        const bottomLeft = start;
+        const topRight = new Point2D(bottomLeft.x + this.width, bottomLeft.y + this.height);
+        const bottomRight = new Point2D(topRight.x, bottomLeft.y);
+        const topLeft = new Point2D(bottomLeft.x, topRight.y);
+        let segment1 = Geometry.makeSegment(plane.localToWorld(bottomLeft), plane.localToWorld(bottomRight));
+        let segment2 = Geometry.makeSegment(plane.localToWorld(bottomRight), plane.localToWorld(topRight));
+        let segment3 = Geometry.makeSegment(plane.localToWorld(topRight), plane.localToWorld(topLeft));
+        let segment4 = Geometry.makeSegment(plane.localToWorld(topLeft), plane.localToWorld(bottomLeft));
+        const result = [
+            Geometry.makeEdge(segment1),
+            Geometry.makeEdge(segment2),
+            Geometry.makeEdge(segment3),
+            Geometry.makeEdge(segment4),
+        ];
+        this.setState('bottomEdge', result[0]);
+        this.setState('rightEdge', result[1]);
+        this.setState('topEdge', result[2]);
+        this.setState('leftEdge', result[3]);
+        return result;
+    }
+    buildRoundedRect(start, plane) {
+        const radius = Array.isArray(this._radius) ? this._radius :
+            [this._radius,
+                this._radius || 0,
+                this._radius || 0,
+                this._radius || 0];
+        const [bottomLeftRadius, bottomRightRadius, topRightRadius, topLeftRadius] = radius;
+        const bottomLeft = start;
+        const topRight = new Point2D(bottomLeft.x + this.width, bottomLeft.y + this.height);
+        const bottomLeftArcCenter = new Point2D(bottomLeft.x + bottomLeftRadius, bottomLeft.y + bottomLeftRadius);
+        const bottomRightArcCenter = new Point2D(topRight.x - bottomRightRadius, bottomLeft.y + bottomRightRadius);
+        const topRightArcCenter = new Point2D(topRight.x - topRightRadius, topRight.y - topRightRadius);
+        const topLeftArcCenter = new Point2D(bottomLeft.x + topLeftRadius, topRight.y - topLeftRadius);
+        const bottomLineStart = new Point2D(bottomLeft.x + bottomLeftRadius, bottomLeft.y);
+        const bottomLineEnd = new Point2D(topRight.x - bottomRightRadius, bottomLeft.y);
+        const rightLineStart = new Point2D(topRight.x, bottomLeft.y + bottomRightRadius);
+        const rightLineEnd = new Point2D(topRight.x, topRight.y - topRightRadius);
+        const topLineStart = new Point2D(topRight.x - topRightRadius, topRight.y);
+        const topLineEnd = new Point2D(bottomLeft.x + topLeftRadius, topRight.y);
+        const leftLineStart = new Point2D(bottomLeft.x, topRight.y - topLeftRadius);
+        const leftLineEnd = new Point2D(bottomLeft.x, bottomLeft.y + bottomLeftRadius);
+        const localToWorld = plane.localToWorld.bind(plane);
+        const bottomLineSegment = Geometry.makeSegment(localToWorld(bottomLineStart), localToWorld(bottomLineEnd));
+        const rightLineSegment = Geometry.makeSegment(localToWorld(rightLineStart), localToWorld(rightLineEnd));
+        const topLineSegment = Geometry.makeSegment(localToWorld(topLineStart), localToWorld(topLineEnd));
+        const leftLineSegment = Geometry.makeSegment(localToWorld(leftLineStart), localToWorld(leftLineEnd));
+        let bottomRightArcEdge = null;
+        if (bottomRightRadius > 0) {
+            const arc = Geometry.makeArc(localToWorld(bottomRightArcCenter), bottomRightRadius, plane.normal, localToWorld(bottomLineEnd), localToWorld(rightLineStart));
+            bottomRightArcEdge = Geometry.makeEdgeFromCurve(arc);
+        }
+        let topRightArcEdge = null;
+        if (topRightRadius > 0) {
+            const arc = Geometry.makeArc(localToWorld(topRightArcCenter), topRightRadius, plane.normal, localToWorld(rightLineEnd), localToWorld(topLineStart));
+            topRightArcEdge = Geometry.makeEdgeFromCurve(arc);
+        }
+        let topLeftArcEdge = null;
+        if (topLeftRadius > 0) {
+            const arc = Geometry.makeArc(localToWorld(topLeftArcCenter), topLeftRadius, plane.normal, localToWorld(topLineEnd), localToWorld(leftLineStart));
+            topLeftArcEdge = Geometry.makeEdgeFromCurve(arc);
+        }
+        let bottomLeftArcEdge = null;
+        if (bottomLeftRadius > 0) {
+            const arc = Geometry.makeArc(localToWorld(bottomLeftArcCenter), bottomLeftRadius, plane.normal, localToWorld(leftLineEnd), localToWorld(bottomLineStart));
+            bottomLeftArcEdge = Geometry.makeEdgeFromCurve(arc);
+        }
+        const bottomEdge = Geometry.makeEdge(bottomLineSegment);
+        const rightEdge = Geometry.makeEdge(rightLineSegment);
+        const topEdge = Geometry.makeEdge(topLineSegment);
+        const leftEdge = Geometry.makeEdge(leftLineSegment);
+        this.setState('bottomEdge', bottomEdge);
+        this.setState('rightEdge', rightEdge);
+        this.setState('topEdge', topEdge);
+        this.setState('leftEdge', leftEdge);
+        this.setState('bottomRightArcEdge', bottomRightArcEdge);
+        this.setState('topRightArcEdge', topRightArcEdge);
+        this.setState('topLeftArcEdge', topLeftArcEdge);
+        this.setState('bottomLeftArcEdge', bottomLeftArcEdge);
+        return [
+            bottomEdge,
+            bottomRightArcEdge,
+            rightEdge,
+            topRightArcEdge,
+            topEdge,
+            topLeftArcEdge,
+            leftEdge,
+            bottomLeftArcEdge,
+        ].filter(e => e !== null);
+    }
+    getType() {
+        return 'rect';
+    }
+    getDependencies() {
+        return this.targetPlane ? [this.targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const rect = new Rect(this.width, this.height, targetPlane);
+        if (this._radius) {
+            rect.radius(...(Array.isArray(this._radius) ? this._radius : [this._radius]));
+        }
+        rect.center(this._center);
+        return rect;
+    }
+    compareTo(other) {
+        if (!(other instanceof Rect)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        if (this.width !== other.width || this.height !== other.height || this._center !== other._center) {
+            return false;
+        }
+        const thisRadius = Array.isArray(this._radius) ? this._radius : [this._radius || 0,
+            this._radius || 0,
+            this._radius || 0,
+            this._radius || 0];
+        const otherRadius = Array.isArray(other._radius) ? other._radius : [other._radius || 0,
+            other._radius || 0,
+            other._radius || 0,
+            other._radius || 0];
+        return thisRadius.every((r, i) => r === otherRadius[i]);
+    }
+    topEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('top-edge'), (parent) => [parent.getState('topEdge')], this);
+    }
+    bottomEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('bottom-edge'), (parent) => [parent.getState('bottomEdge')], this);
+    }
+    leftEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('left-edge'), (parent) => [parent.getState('leftEdge')], this);
+    }
+    rightEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('right-edge'), (parent) => [parent.getState('rightEdge')], this);
+    }
+    topLeftArcEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('top-left-arc'), (parent) => [parent.getState('topLeftArcEdge')], this);
+    }
+    topRightArcEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('top-right-arc'), (parent) => [parent.getState('topRightArcEdge')], this);
+    }
+    bottomLeftArcEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('bottom-left-arc'), (parent) => [parent.getState('bottomLeftArcEdge')], this);
+    }
+    bottomRightArcEdge() {
+        return new LazySelectionSceneObject(this.generateUniqueName('bottom-right-arc'), (parent) => [parent.getState('bottomRightArcEdge')], this);
+    }
+    topLeft() {
+        return new LazyVertex(this.generateUniqueName('top-left-vertex'), () => {
+            const edge = this.getState('topEdge');
+            if (!edge) {
+                return [];
+            }
+            return [edge.getLastVertex()];
+        });
+    }
+    topRight() {
+        return new LazyVertex(this.generateUniqueName('top-right-vertex'), () => {
+            const edge = this.getState('topEdge');
+            if (!edge) {
+                return [];
+            }
+            return [edge.getFirstVertex()];
+        });
+    }
+    bottomLeft() {
+        return new LazyVertex(this.generateUniqueName('bottom-left-vertex'), () => {
+            const edge = this.getState('bottomEdge');
+            if (!edge) {
+                return [];
+            }
+            return [edge.getFirstVertex()];
+        });
+    }
+    bottomRight() {
+        return new LazyVertex(this.generateUniqueName('bottom-right-vertex'), () => {
+            const edge = this.getState('bottomEdge');
+            if (!edge) {
+                return [];
+            }
+            return [edge.getLastVertex()];
+        });
+    }
+    radius(...r) {
+        if (r.length === 1) {
+            this._radius = r[0];
+        }
+        else {
+            this._radius = r;
+        }
+        return this;
+    }
+    center(value = true) {
+        this._center = value;
+        return this;
+    }
+    serialize() {
+        return {
+            width: this.width,
+            height: this.height,
+            radius: this._radius,
+            center: this._center
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export declare class RMove extends GeometrySceneObject {
+    pivot: LazyVertex;
+    angle: number;
+    constructor(pivot: LazyVertex, angle: number);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        pivot: LazyVertex;
+        angle: number;
+    };
+}

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

@@ -0,0 +1,39 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class RMove extends GeometrySceneObject {
+    pivot;
+    angle;
+    constructor(pivot, angle) {
+        super();
+        this.pivot = pivot;
+        this.angle = angle;
+    }
+    getType() {
+        return 'rmove';
+    }
+    build() {
+        const pos = this.getCurrentPosition();
+        const newPos = pos.rotate(this.angle, this.pivot.asPoint2D());
+        this.setCurrentPosition(newPos);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new RMove(this.pivot, this.angle);
+    }
+    compareTo(other) {
+        if (!(other instanceof RMove)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.pivot.compareTo(other.pivot) && this.angle === other.angle;
+    }
+    serialize() {
+        return {
+            pivot: this.pivot,
+            angle: this.angle
+        };
+    }
+}

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

@@ -0,0 +1,34 @@
+import { Plane } from "../../math/plane.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { Edge } from "../../common/edge.js";
+import { Extrudable } from "../../helpers/types.js";
+export declare class Sketch extends SceneObject implements Extrudable {
+    planeObj: PlaneObjectBase;
+    constructor(planeObj: PlaneObjectBase);
+    isContainer(): boolean;
+    isExtrudable(): boolean;
+    getPlane(): Plane;
+    getStartPoint(): Point2D;
+    getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
+    getPositionAt(currentObj: GeometrySceneObject): Point2D;
+    getLastPosition(): Point2D;
+    build(): void;
+    getEdges(): Edge[];
+    getEdgesWithOwner(): Map<Edge, GeometrySceneObject>;
+    getGeometriesWithOwner(): Map<Edge, GeometrySceneObject>;
+    getGeometries(): Edge[];
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Sketch): boolean;
+    getTangent(): Point2D | null;
+    getType(): string;
+    serialize(): {
+        currentPosition: import("../../math/point.js").Point;
+        currentTangent: import("../../math/point.js").Point;
+        plane: any;
+    };
+    toString(): string;
+}

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

@@ -0,0 +1,171 @@
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { Edge } from "../../common/edge.js";
+import { Wire } from "../../common/wire.js";
+export class Sketch extends SceneObject {
+    planeObj;
+    constructor(planeObj) {
+        super();
+        this.planeObj = planeObj;
+    }
+    isContainer() {
+        return true;
+    }
+    isExtrudable() {
+        return true;
+    }
+    getPlane() {
+        return this.planeObj.getPlane();
+    }
+    getStartPoint() {
+        const center = this.planeObj.getPlaneCenter();
+        if (center) {
+            const plane = this.getPlane();
+            return plane.worldToLocal(center);
+        }
+        return new Point2D(0, 0);
+    }
+    getTangentAt(currentObj) {
+        const children = this.getChildren();
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let last = previous[previous.length - 1];
+        while (last) {
+            const tangent = last.getTangent();
+            if (tangent) {
+                return tangent;
+            }
+            previous.pop();
+            last = previous[previous.length - 1];
+        }
+        return null;
+    }
+    getPositionAt(currentObj) {
+        const children = this.getChildren();
+        if (children.length === 1) {
+            return this.getStartPoint();
+        }
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let last = previous[previous.length - 1];
+        while (last) {
+            const pos = last.getState('current-position');
+            if (pos) {
+                return pos;
+            }
+            previous.pop();
+            last = previous[previous.length - 1];
+        }
+        return this.getStartPoint();
+    }
+    getLastPosition() {
+        const children = this.getChildren().slice();
+        if (children.length === 0) {
+            return this.getStartPoint();
+        }
+        while (true) {
+            const last = children[children.length - 1];
+            if (!last) {
+                return this.getStartPoint();
+            }
+            const pos = last.getState('current-position');
+            if (pos) {
+                return pos;
+            }
+            children.pop();
+        }
+    }
+    build() {
+        this.planeObj.removeShapes(this);
+    }
+    getEdges() {
+        return [...this.getEdgesWithOwner().keys()];
+    }
+    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.getAddedShapes();
+            const removedShapes = child.getRemovedShapes();
+            for (const shape of shapes) {
+                if (shape.isMetaShape() || shape.isGuideShape()) {
+                    continue;
+                }
+                const isRemovedBySibling = removedShapes.some(s => s.shape === shape && s.removedBy?.parentId === this.id);
+                if (isRemovedBySibling) {
+                    continue;
+                }
+                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;
+    }
+    getGeometriesWithOwner() {
+        return this.getEdgesWithOwner();
+    }
+    getGeometries() {
+        return this.getEdges();
+    }
+    getDependencies() {
+        return [this.planeObj];
+    }
+    createCopy(remap) {
+        const planeObj = remap.get(this.planeObj) || this.planeObj;
+        return new Sketch(planeObj);
+    }
+    compareTo(other) {
+        if (!(other instanceof Sketch)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.getOrder() !== other.getOrder()) {
+            return false;
+        }
+        return true;
+    }
+    getTangent() {
+        let children = this.getChildren()?.slice();
+        if (children.length === 0) {
+            return null;
+        }
+        let last = children[children.length - 1];
+        while (last) {
+            if (!(last instanceof GeometrySceneObject)) {
+                children.pop();
+                last = children[children.length - 1];
+                continue;
+            }
+            const tangent = last.getTangent();
+            if (tangent) {
+                return tangent;
+            }
+            children.pop();
+            last = children[children.length - 1];
+        }
+        return null;
+    }
+    getType() {
+        return "sketch";
+    }
+    serialize() {
+        const plane = this.getPlane();
+        const tangent = this.getTangent();
+        return {
+            currentPosition: plane.localToWorld(this.getLastPosition()),
+            currentTangent: tangent ? plane.localToWorld(tangent) : null,
+            plane: this.planeObj.serialize(),
+        };
+    }
+    toString() {
+        return `Sketch`;
+    }
+}

package/lib/dist/features/2d/slot-from-edge.d.ts

@@ -0,0 +1,19 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export declare class SlotFromEdge extends ExtrudableGeometryBase {
+    sourceGeometry: GeometrySceneObject;
+    radius: number;
+    deleteSource: boolean;
+    constructor(sourceGeometry: GeometrySceneObject, radius: number, deleteSource?: boolean, targetPlane?: PlaneObjectBase);
+    build(): void;
+    getType(): string;
+    getUniqueType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SlotFromEdge): boolean;
+    serialize(): {
+        radius: number;
+    };
+}

package/lib/dist/features/2d/slot-from-edge.js

@@ -0,0 +1,66 @@
+import { WireOps } from "../../oc/wire-ops.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class SlotFromEdge extends ExtrudableGeometryBase {
+    sourceGeometry;
+    radius;
+    deleteSource;
+    constructor(sourceGeometry, radius, deleteSource = true, targetPlane = null) {
+        super(targetPlane);
+        this.sourceGeometry = sourceGeometry;
+        this.radius = radius;
+        this.deleteSource = deleteSource;
+    }
+    build() {
+        const shapes = this.sourceGeometry.getShapes({ excludeGuide: false });
+        if (shapes.length === 0) {
+            throw new Error("SlotFromEdge: source geometry has no edges or wires");
+        }
+        for (const shape of shapes) {
+            if (shape.isEdge() || shape.isWire()) {
+                const wire = WireOps.offsetWire(shape, this.radius, false);
+                this.addShapes(wire.getEdges());
+            }
+        }
+        if (this.deleteSource) {
+            this.sourceGeometry.removeShapes(this);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    getType() {
+        return 'slot';
+    }
+    getUniqueType() {
+        return 'slot-from-edge';
+    }
+    getDependencies() {
+        return this.targetPlane ? [this.targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new SlotFromEdge(this.sourceGeometry, this.radius, this.deleteSource, targetPlane);
+    }
+    compareTo(other) {
+        if (!(other instanceof SlotFromEdge)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.sourceGeometry.compareTo(other.sourceGeometry) &&
+            this.radius === other.radius &&
+            this.deleteSource === other.deleteSource;
+    }
+    serialize() {
+        return {
+            radius: this.radius,
+        };
+    }
+}

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

@@ -0,0 +1,24 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { ISlot } from "../../core/interfaces.js";
+export declare class Slot extends ExtrudableGeometryBase implements ISlot {
+    distance: number;
+    radius: number;
+    private _center;
+    private _angle;
+    constructor(distance: number, radius: number, targetPlane?: PlaneObjectBase);
+    center(value?: boolean): this;
+    rotate(angle: number): this;
+    build(): void;
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Slot): boolean;
+    serialize(): {
+        distance: number;
+        radius: number;
+        center: boolean;
+        angle: number;
+    };
+}