fluidcad 0.0.29 → 0.0.30

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

@@ -1,20 +1,25 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { rad } from "../../helpers/math-helpers.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class AngledLine extends GeometrySceneObject {
-    length;
     angle;
-    centered;
+    lengthOrTarget;
     targetPlane;
-    constructor(length, angle, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(angle, lengthOrTarget, targetPlane = null) {
         super();
-        this.length = length;
         this.angle = angle;
-        this.centered = centered;
+        this.lengthOrTarget = lengthOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         let tangent = this.sketch?.getTangentAt(this) || new Point2D(1, 0);
@@ -29,27 +34,63 @@ export class AngledLine extends GeometrySceneObject {
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(-direction.x * this.length / 2, -direction.y * this.length / 2)
-            : currentPos;
+        let startPoint;
+        let endPoint;
+        if (typeof this.lengthOrTarget === 'number') {
+            const length = this.lengthOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(-direction.x * length / 2, -direction.y * length / 2)
+                : currentPos;
+            endPoint = startPoint.translate(direction.x * length, direction.y * length);
+        }
+        else {
+            if (this._centered) {
+                throw new Error('aLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, direction, this.lengthOrTarget);
+        }
         const start = plane.localToWorld(startPoint);
-        const worldDir = plane.xDirection.multiply(direction.x).add(plane.yDirection.multiply(direction.y));
-        const end = start.add(worldDir.multiply(this.length));
-        const endPoint = plane.worldToLocal(end);
+        const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
         const edge = Geometry.makeEdge(segment);
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        this.setTangent(direction.normalize());
-        if (this.sketch)
+        // Tangent at end points from start to end (sign-aware when target is behind start)
+        const endTangent = endPoint.subtract(startPoint);
+        const endLen = Math.hypot(endTangent.x, endTangent.y);
+        if (endLen > 1e-12) {
+            this.setTangent(new Point2D(endTangent.x / endLen, endTangent.y / endLen));
+        }
+        else {
+            this.setTangent(direction.normalize());
+        }
+        if (this.sketch) {
             this.setCurrentPosition(endPoint);
-        if (this.targetPlane)
+        }
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.lengthOrTarget instanceof SceneObject) {
+            deps.push(this.lengthOrTarget);
+        }
+        return deps;
     }
     createCopy(remap) {
         const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
-        return new AngledLine(this.length, this.angle, this.centered, targetPlane);
+        const lengthOrTarget = this.lengthOrTarget instanceof SceneObject
+            ? (remap.get(this.lengthOrTarget) || this.lengthOrTarget)
+            : this.lengthOrTarget;
+        const copy = new AngledLine(this.angle, lengthOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof AngledLine)) {
@@ -64,7 +105,18 @@ export class AngledLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.length === other.length && this.angle === other.angle && this.centered === other.centered;
+        if (typeof this.lengthOrTarget !== typeof other.lengthOrTarget) {
+            return false;
+        }
+        if (this.lengthOrTarget instanceof SceneObject && other.lengthOrTarget instanceof SceneObject) {
+            if (!this.lengthOrTarget.compareTo(other.lengthOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.lengthOrTarget !== other.lengthOrTarget) {
+            return false;
+        }
+        return this.angle === other.angle && this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -74,9 +126,9 @@ export class AngledLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            length: this.length,
             angle: this.angle,
-            centered: this.centered
+            length: typeof this.lengthOrTarget === 'number' ? this.lengthOrTarget : null,
+            centered: this._centered
         };
     }
 }

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

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

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

@@ -0,0 +1,35 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class Back extends GeometrySceneObject {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    getType() {
+        return 'back';
+    }
+    build() {
+        const target = this.sketch.getPreviousPosition(this, this.count);
+        this.setCurrentPosition(target);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new Back(this.count);
+    }
+    compareTo(other) {
+        if (!(other instanceof Back)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.count === other.count;
+    }
+    serialize() {
+        return {
+            count: this.count
+        };
+    }
+}

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

@@ -1,11 +1,16 @@
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class HorizontalLine extends GeometrySceneObject {
-    distance: number;
-    centered: boolean;
+import { IHLine } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class HorizontalLine extends GeometrySceneObject implements IHLine {
+    distanceOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: HorizontalLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -2,25 +2,45 @@ import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class HorizontalLine extends GeometrySceneObject {
-    distance;
-    centered;
+    distanceOrTarget;
     targetPlane;
-    constructor(distance, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(distanceOrTarget, targetPlane = null) {
         super();
-        this.distance = distance;
-        this.centered = centered;
+        this.distanceOrTarget = distanceOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(-this.distance / 2, 0)
-            : currentPos;
-        const endPoint = startPoint.translate(this.distance, 0);
+        let startPoint;
+        let endPoint;
+        let signedLength;
+        if (typeof this.distanceOrTarget === 'number') {
+            const distance = this.distanceOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(-distance / 2, 0)
+                : currentPos;
+            endPoint = startPoint.translate(distance, 0);
+            signedLength = distance;
+        }
+        else {
+            if (this._centered) {
+                throw new Error('hLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(1, 0), this.distanceOrTarget);
+            signedLength = endPoint.x - startPoint.x;
+        }
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
@@ -28,13 +48,33 @@ export class HorizontalLine extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        const sign = Math.sign(this.distance) || 1;
+        const sign = Math.sign(signedLength) || 1;
         this.setTangent(new Point2D(sign, 0));
         if (this.sketch) {
             this.setCurrentPosition(endPoint);
         }
-        if (this.targetPlane)
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.distanceOrTarget instanceof SceneObject) {
+            deps.push(this.distanceOrTarget);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        const copy = new HorizontalLine(distanceOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof HorizontalLine)) {
@@ -49,7 +89,18 @@ export class HorizontalLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.distance === other.distance && this.centered === other.centered;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            if (!this.distanceOrTarget.compareTo(other.distanceOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.distanceOrTarget !== other.distanceOrTarget) {
+            return false;
+        }
+        return this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -59,8 +110,8 @@ export class HorizontalLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            distance: this.distance,
-            centered: this.centered
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
+            centered: this._centered
         };
     }
 }

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

@@ -14,6 +14,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getStartPoint(): Point2D;
     getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
+    getPreviousPosition(currentObj: GeometrySceneObject, count?: number): Point2D;
     getLastPosition(scope?: Set<SceneObject>): Point2D;
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];

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

@@ -58,6 +58,21 @@ export class Sketch extends SceneObject {
         }
         return this.getStartPoint();
     }
+    getPreviousPosition(currentObj, count = 1) {
+        const children = this.getChildren();
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let remaining = count;
+        for (let i = previous.length - 1; i >= 0; i--) {
+            const pos = previous[i].getState('current-position');
+            if (pos) {
+                if (remaining === 0) {
+                    return pos;
+                }
+                remaining--;
+            }
+        }
+        return this.getStartPoint();
+    }
     getLastPosition(scope) {
         let children = this.getChildren().slice();
         if (scope) {

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

@@ -1,11 +1,16 @@
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class VerticalLine extends GeometrySceneObject {
-    distance: number;
-    centered: boolean;
+import { IVLine } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class VerticalLine extends GeometrySceneObject implements IVLine {
+    distanceOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: VerticalLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -2,25 +2,45 @@ import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class VerticalLine extends GeometrySceneObject {
-    distance;
-    centered;
+    distanceOrTarget;
     targetPlane;
-    constructor(distance, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(distanceOrTarget, targetPlane = null) {
         super();
-        this.distance = distance;
-        this.centered = centered;
+        this.distanceOrTarget = distanceOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(0, -this.distance / 2)
-            : currentPos;
-        const endPoint = startPoint.translate(0, this.distance);
+        let startPoint;
+        let endPoint;
+        let signedLength;
+        if (typeof this.distanceOrTarget === 'number') {
+            const distance = this.distanceOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(0, -distance / 2)
+                : currentPos;
+            endPoint = startPoint.translate(0, distance);
+            signedLength = distance;
+        }
+        else {
+            if (this._centered) {
+                throw new Error('vLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(0, 1), this.distanceOrTarget);
+            signedLength = endPoint.y - startPoint.y;
+        }
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
@@ -28,12 +48,33 @@ export class VerticalLine extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        const sign = Math.sign(this.distance) || 1;
+        const sign = Math.sign(signedLength) || 1;
         this.setTangent(new Point2D(0, sign));
-        if (this.sketch)
+        if (this.sketch) {
             this.setCurrentPosition(endPoint);
-        if (this.targetPlane)
+        }
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.distanceOrTarget instanceof SceneObject) {
+            deps.push(this.distanceOrTarget);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        const copy = new VerticalLine(distanceOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof VerticalLine)) {
@@ -48,7 +89,18 @@ export class VerticalLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.distance === other.distance && this.centered === other.centered;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            if (!this.distanceOrTarget.compareTo(other.distanceOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.distanceOrTarget !== other.distanceOrTarget) {
+            return false;
+        }
+        return this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -58,8 +110,8 @@ export class VerticalLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            distance: this.distance,
-            centered: this.centered
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
+            centered: this._centered
         };
     }
 }

package/lib/dist/features/lazy-scene-object.d.ts

@@ -7,6 +7,7 @@ export declare class LazySelectionSceneObject extends SceneObject {
     private _originalParent;
     constructor(uniqueName: string, getShapesFn: (parent: SceneObject) => Shape[], sourceParent: SceneObject);
     build(): void;
+    isLazy(): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: LazySelectionSceneObject): boolean;

package/lib/dist/features/lazy-scene-object.js

@@ -14,6 +14,9 @@ export class LazySelectionSceneObject extends SceneObject {
         const shapes = this.getShapesFn(this.sourceParent);
         this.addShapes(shapes);
     }
+    isLazy() {
+        return true;
+    }
     getDependencies() {
         return [this.sourceParent];
     }

package/lib/dist/features/lazy-vertex.d.ts

@@ -8,6 +8,7 @@ export declare class LazyVertex extends SceneObject {
     private _isBuilt;
     constructor(uniqueName: string, getShapesFn: () => Shape[]);
     build(): void;
+    isLazy(): boolean;
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     asPoint(): import("../math/point.js").Point;
     asPoint2D(): import("../math/point.js").Point2D;

package/lib/dist/features/lazy-vertex.js

@@ -19,6 +19,9 @@ export class LazyVertex extends SceneObject {
         }
         this.addShapes(shapes);
     }
+    isLazy() {
+        return true;
+    }
     getShapes(filter, type) {
         if (this._isBuilt) {
             return super.getShapes(filter, type);

package/lib/dist/features/mirror-shape.d.ts

@@ -3,7 +3,9 @@ import { PlaneObjectBase } from "./plane-renderable-base.js";
 export declare class MirrorShape extends SceneObject {
     private plane;
     targetObjects: SceneObject[] | null;
+    private _excludedObjects;
     constructor(plane: PlaneObjectBase, targetObjects?: SceneObject[] | null);
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: MirrorShape): boolean;
     getType(): string;

package/lib/dist/features/mirror-shape.js

@@ -5,11 +5,16 @@ import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
 export class MirrorShape extends SceneObject {
     plane;
     targetObjects;
+    _excludedObjects = [];
     constructor(plane, targetObjects = null) {
         super();
         this.plane = plane;
         this.targetObjects = targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let objects;
         let targetObjects = this.targetObjects;
@@ -30,6 +35,9 @@ export class MirrorShape extends SceneObject {
         else {
             targetObjects = lastObj ? [lastObj] : objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         if (this.plane) {
             this.plane.removeShapes(this);
         }
@@ -81,6 +89,14 @@ export class MirrorShape extends SceneObject {
                 return false;
             }
         }
+        if (this._excludedObjects.length !== other._excludedObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this._excludedObjects.length; i++) {
+            if (!this._excludedObjects[i].compareTo(other._excludedObjects[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {

package/lib/dist/features/mirror-shape2d.d.ts

@@ -5,7 +5,9 @@ import { LazyVertex } from "./lazy-vertex.js";
 export declare class MirrorShape2D extends GeometrySceneObject {
     private axis;
     private targetObjects;
+    private _excludedObjects;
     constructor(axis: AxisObjectBase, targetObjects?: SceneObject[]);
+    exclude(...objects: SceneObject[]): this;
     build(context: BuildSceneObjectContext): void;
     start(): LazyVertex;
     end(): LazyVertex;

package/lib/dist/features/mirror-shape2d.js

@@ -6,11 +6,16 @@ import { Vertex } from "../common/vertex.js";
 export class MirrorShape2D extends GeometrySceneObject {
     axis;
     targetObjects;
+    _excludedObjects = [];
     constructor(axis, targetObjects = null) {
         super();
         this.axis = axis;
         this.targetObjects = targetObjects;
     }
+    exclude(...objects) {
+        this._excludedObjects.push(...objects);
+        return this;
+    }
     build(context) {
         let targetObjects = this.targetObjects;
         let sketch = this.sketch;
@@ -23,6 +28,9 @@ export class MirrorShape2D extends GeometrySceneObject {
         else {
             targetObjects = objects;
         }
+        if (this._excludedObjects.length > 0) {
+            targetObjects = targetObjects.filter(obj => !this._excludedObjects.includes(obj));
+        }
         this.axis.removeShapes(this);
         axis = this.axis.getAxis();
         const transformedShapes = [];
@@ -79,7 +87,12 @@ export class MirrorShape2D extends GeometrySceneObject {
         const targetObjects = this.targetObjects
             ? this.targetObjects.map(obj => remap.get(obj) || obj)
             : null;
-        return new MirrorShape2D(axis, targetObjects);
+        const copy = new MirrorShape2D(axis, targetObjects);
+        if (this._excludedObjects.length > 0) {
+            const remappedExcluded = this._excludedObjects.map(obj => remap.get(obj) || obj);
+            copy.exclude(...remappedExcluded);
+        }
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof MirrorShape2D)) {
@@ -101,6 +114,14 @@ export class MirrorShape2D extends GeometrySceneObject {
                 return false;
             }
         }
+        if (this._excludedObjects.length !== other._excludedObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this._excludedObjects.length; i++) {
+            if (!this._excludedObjects[i].compareTo(other._excludedObjects[i])) {
+                return false;
+            }
+        }
         return true;
     }
     getType() {