chili3d 0.6.1

package/packages/chili/src/commands/modify/trim.ts

@@ -0,0 +1,254 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    AsyncController,
+    BoundingBox,
+    CancelableCommand,
+    command,
+    EditableShapeNode,
+    type GeometryNode,
+    I18n,
+    type ICurve,
+    type IDisposable,
+    type IDocument,
+    type IEdge,
+    type IShape,
+    type IShapeFilter,
+    type ITrimmedCurve,
+    type IView,
+    type IVisualGeometry,
+    type ShapeNode,
+    ShapeType,
+    Transaction,
+    VisualConfig,
+    type VisualShapeData,
+} from "chili-core";
+import { GeoUtils } from "chili-geo";
+import { ShapeSelectionHandler } from "chili-vis";
+
+@command({
+    key: "modify.trim",
+    icon: "icon-trim",
+})
+export class Trim extends CancelableCommand {
+    protected override async executeAsync() {
+        const transaction = new Transaction(this.document, I18n.translate("command.modify.trim"));
+        transaction.start();
+        try {
+            await this.trimAsync();
+        } catch (e) {
+            transaction.rollback();
+            throw e;
+        }
+        transaction.commit();
+    }
+
+    private async trimAsync() {
+        this.document.visual.highlighter.clear();
+        this.document.selection.clearSelection();
+
+        while (!this.isCompleted) {
+            this.controller = new AsyncController();
+            const handler = new PickTrimEdgeEventHandler(this.document, this.controller);
+            await this.document.selection.pickAsync(
+                handler,
+                "prompt.select.edges",
+                this.controller,
+                false,
+                "select.default",
+            );
+            if (this.controller.result?.status !== "success" || !handler.selected) {
+                break;
+            }
+            this.trimEdge(handler.selected);
+            handler.dispose();
+        }
+    }
+
+    private trimEdge(selected: TrimEdge) {
+        const model = this.document.visual.context.getNode(selected.edge.owner);
+        const materialId = (model as GeometryNode)?.materialId;
+        selected.segments.retainSegments.forEach((segment) => {
+            const newEdge = selected.curve.trim(segment.start, segment.end).makeEdge();
+            model?.parent?.add(new EditableShapeNode(this.document, model.name, newEdge, materialId));
+        });
+        model?.parent?.remove(model);
+    }
+}
+
+export class EdgeFilter implements IShapeFilter {
+    allow(shape: IShape): boolean {
+        return shape.shapeType === ShapeType.Edge;
+    }
+}
+
+interface TrimEdge {
+    edge: VisualShapeData;
+    curve: ICurve;
+    segments: {
+        deleteSegment: {
+            start: number;
+            end: number;
+        };
+        retainSegments: {
+            start: number;
+            end: number;
+        }[];
+    };
+}
+
+export class PickTrimEdgeEventHandler extends ShapeSelectionHandler {
+    #selected: TrimEdge | undefined;
+    private highlightedEdge: number | undefined;
+    private highlight: undefined | TrimEdge;
+    private readonly releaseStack = new Set<IDisposable>();
+
+    get selected() {
+        return this.#selected;
+    }
+
+    constructor(document: IDocument, controller: AsyncController) {
+        super(document, ShapeType.Shape, false, controller, new EdgeFilter());
+    }
+
+    protected override highlightDetecteds(view: IView, detecteds: VisualShapeData[]): void {
+        this.cleanHighlights();
+        if (detecteds.length !== 1 || detecteds[0].shape.shapeType !== ShapeType.Edge) return;
+
+        const box = BoundingBox.transformed(detecteds[0].owner.boundingBox()!, detecteds[0].transform);
+        const edges = this.filterByBoundingBox(box, view, detecteds[0].shape);
+        const edge = detecteds[0].shape.transformedMul(detecteds[0].transform) as IEdge;
+        this.releaseStack.add(edge);
+
+        const segments = findSegments(edge.curve, edge, edges, detecteds);
+        const mesh = edge.trim(segments.deleteSegment.start, segments.deleteSegment.end).mesh.edges!;
+        mesh.color = VisualConfig.highlightEdgeColor;
+        mesh.lineWidth = 3;
+        this.highlightedEdge = view.document.visual.highlighter.highlightMesh(mesh);
+        this.highlight = { edge: detecteds[0], segments, curve: edge.curve };
+        view.update();
+    }
+
+    protected override cleanHighlights(): void {
+        if (this.highlightedEdge !== undefined) {
+            this.document.visual.highlighter.removeHighlightMesh(this.highlightedEdge);
+            this.highlightedEdge = undefined;
+            this.highlight = undefined;
+            this.document.application.activeView?.update();
+        }
+    }
+
+    protected override clearSelected(document: IDocument): void {
+        this.#selected = undefined;
+    }
+
+    protected override select(view: IView, event: PointerEvent): number {
+        this.#selected = this.highlight;
+        return this.#selected ? 1 : 0;
+    }
+
+    private filterByBoundingBox(box: BoundingBox, view: IView, currentShape: IShape) {
+        const boundingBox = BoundingBox.expand(box, 1e-3);
+        return view.document.visual.context
+            .boundingBoxIntersectFilter(boundingBox, new EdgeFilter())
+            .map((x) => {
+                const node = (x as IVisualGeometry)?.geometryNode;
+                const shape = (node as ShapeNode)?.shape?.value;
+                if (!shape || shape === currentShape) return undefined;
+                const edge = shape.transformedMul(node.worldTransform()) as IEdge;
+                this.releaseStack.add(edge);
+                return edge;
+            })
+            .filter((x) => x !== undefined);
+    }
+
+    override disposeInternal(): void {
+        super.disposeInternal();
+
+        this.releaseStack.forEach((x) => x.dispose());
+        this.releaseStack.clear();
+    }
+}
+
+function findSegments(curve: ITrimmedCurve, edge: IEdge, otherEdges: IEdge[], detecteds: VisualShapeData[]) {
+    let intersections = GeoUtils.intersects(edge, otherEdges).map((x) => x.parameter);
+    intersections.push(curve.firstParameter(), curve.lastParameter());
+    intersections = Array.from(new Set(intersections)).sort((a, b) => a - b);
+
+    if (intersections.length === 2) return allSegment(intersections);
+
+    const parameter = curve.parameter(detecteds[0].point!, 5)!;
+    for (let i = 1; i < intersections.length; i++) {
+        if (parameter < intersections[i]) {
+            if (i === 1) {
+                return startSegment(intersections);
+            } else if (i === intersections.length - 1) {
+                return lastSegment(intersections);
+            } else {
+                return centerSegment(intersections, i);
+            }
+        }
+    }
+
+    return allSegment(intersections);
+}
+
+function allSegment(intersections: number[]) {
+    return {
+        deleteSegment: {
+            start: intersections[0],
+            end: intersections.at(-1)!,
+        },
+        retainSegments: [],
+    };
+}
+
+function centerSegment(intersections: number[], i: number) {
+    return {
+        deleteSegment: {
+            start: intersections.at(i - 1)!,
+            end: intersections.at(i)!,
+        },
+        retainSegments: [
+            {
+                start: intersections[0],
+                end: intersections[i - 1],
+            },
+            {
+                start: intersections[i],
+                end: intersections.at(-1)!,
+            },
+        ],
+    };
+}
+
+function lastSegment(intersections: number[]) {
+    return {
+        deleteSegment: {
+            start: intersections.at(-2)!,
+            end: intersections.at(-1)!,
+        },
+        retainSegments: [
+            {
+                start: intersections[0],
+                end: intersections.at(-2)!,
+            },
+        ],
+    };
+}
+
+function startSegment(intersections: number[]) {
+    return {
+        deleteSegment: {
+            start: intersections[0],
+            end: intersections[1],
+        },
+        retainSegments: [
+            {
+                start: intersections[1],
+                end: intersections.at(-1)!,
+            },
+        ],
+    };
+}

package/packages/chili/src/commands/multistepCommand.ts

@@ -0,0 +1,125 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    AsyncController,
+    CancelableCommand,
+    Config,
+    EdgeMeshData,
+    type IShape,
+    type IShapeFactory,
+    type IView,
+    LineType,
+    Result,
+    VertexMeshData,
+    VisualConfig,
+    type XYZ,
+} from "chili-core";
+import { ViewUtils } from "chili-vis";
+import type { SnapResult } from "../snap";
+import type { IStep } from "../step";
+
+export abstract class MultistepCommand extends CancelableCommand {
+    protected stepDatas: SnapResult[] = [];
+
+    protected canExcute(): Promise<boolean> {
+        return Promise.resolve(true);
+    }
+
+    protected override onRestarting(): void {
+        this.resetStepDatas();
+    }
+
+    protected async executeAsync(): Promise<void> {
+        if (!(await this.canExcute()) || !(await this.executeSteps())) {
+            return;
+        }
+
+        this.executeMainTask();
+    }
+
+    protected async executeSteps(): Promise<boolean> {
+        const steps = this.getSteps();
+
+        return Promise.try(async () => {
+            while (this.stepDatas.length < steps.length) {
+                this.controller = new AsyncController();
+                const data = await steps[this.stepDatas.length].execute(this.document, this.controller);
+                if (data === undefined || this.controller.result?.status !== "success") {
+                    return false;
+                }
+                this.stepDatas.push(data);
+            }
+            return true;
+        }).finally(() => {
+            if (!this._isRestarting) {
+                this.document.selection.clearSelection();
+                this.document.visual.highlighter.clear();
+            }
+        });
+    }
+
+    protected resetStepDatas() {
+        this.stepDatas.length = 0;
+    }
+
+    protected meshPoint(point: XYZ) {
+        return VertexMeshData.from(point, VisualConfig.editVertexSize, VisualConfig.editVertexColor);
+    }
+
+    protected meshLine(start: XYZ, end: XYZ, color = VisualConfig.defaultEdgeColor, lineWith?: number) {
+        const data = EdgeMeshData.from(start, end, color, LineType.Solid);
+        if (lineWith !== undefined) {
+            data.lineWidth = lineWith;
+        }
+        return data;
+    }
+
+    protected meshCreatedShape<K extends keyof IShapeFactory>(
+        method: K,
+        ...args: Parameters<IShapeFactory[K] extends (...args: any) => any ? IShapeFactory[K] : never>
+    ) {
+        const shape = (this.application.shapeFactory as any)[method](...args);
+        return this.meshShape(shape);
+    }
+
+    protected meshShape(shape: IShape | Result<IShape>, disposeShape = true) {
+        if (shape instanceof Result && !shape.isOk) {
+            throw shape.error;
+        }
+
+        const s = shape instanceof Result ? shape.value : shape;
+        const edgeMesh = s.edgesMeshPosition();
+        if (disposeShape) {
+            s.dispose();
+        }
+
+        return edgeMesh;
+    }
+
+    protected readonly findPlane = (view: IView, origin: XYZ, point: XYZ | undefined) => {
+        if (point === undefined || !Config.instance.dynamicWorkplane) {
+            return view.workplane.translateTo(origin);
+        }
+
+        return ViewUtils.raycastClosestPlane(view, origin, point);
+    };
+
+    protected transformdFirstShape(step: SnapResult, shouldDispose = true) {
+        const shape = step.shapes[0].shape.transformedMul(step.shapes[0].transform);
+        if (shouldDispose) this.disposeStack.add(shape);
+        return shape;
+    }
+
+    protected transformdShapes(step: SnapResult, shouldDispose = true) {
+        return step.shapes.map((s) => {
+            const shape = s.shape.transformedMul(s.transform);
+            if (shouldDispose) this.disposeStack.add(shape);
+            return shape;
+        });
+    }
+
+    protected abstract getSteps(): IStep[];
+
+    protected abstract executeMainTask(): void;
+}

package/packages/chili/src/commands/redo.ts

@@ -0,0 +1,16 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, type IApplication, type ICommand } from "chili-core";
+
+@command({
+    key: "edit.redo",
+    icon: "icon-redo",
+})
+export class Redo implements ICommand {
+    async execute(app: IApplication): Promise<void> {
+        const document = app.activeView?.document;
+        document?.history.redo();
+        document?.visual.update();
+    }
+}

package/packages/chili/src/commands/undo.ts

@@ -0,0 +1,16 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, type IApplication, type ICommand } from "chili-core";
+
+@command({
+    key: "edit.undo",
+    icon: "icon-undo",
+})
+export class Undo implements ICommand {
+    async execute(application: IApplication): Promise<void> {
+        const document = application.activeView?.document;
+        document?.history.undo();
+        document?.visual.update();
+    }
+}

package/packages/chili/src/commands/workingPlane.ts

@@ -0,0 +1,150 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { div, RadioGroup } from "chili-controls";
+import {
+    AsyncController,
+    command,
+    DialogResult,
+    I18n,
+    type IApplication,
+    type ICommand,
+    type ICurve,
+    type IEdge,
+    type IFace,
+    Observable,
+    Plane,
+    Property,
+    PubSub,
+    SelectableItems,
+    SelectMode,
+    ShapeType,
+    XYZ,
+} from "chili-core";
+import { Dimension } from "../snap";
+import { type IStep, PointOnCurveStep, SelectShapeStep } from "../step";
+import { MultistepCommand } from "./multistepCommand";
+
+export class WorkingPlaneViewModel extends Observable {
+    @Property.define("dialog.title.selectWorkingPlane")
+    planes: SelectableItems<string> = new SelectableItems(["XOY", "YOZ", "ZOX"], SelectMode.radio, ["XOY"]);
+}
+
+@command({
+    key: "workingPlane.set",
+    icon: "icon-setWorkingPlane",
+})
+export class SetWorkplane implements ICommand {
+    async execute(application: IApplication): Promise<void> {
+        const view = application.activeView;
+        if (!view) return;
+
+        const vm = new WorkingPlaneViewModel();
+        PubSub.default.pub("showDialog", "dialog.title.selectWorkingPlane", this.ui(vm), (result) => {
+            if (result === DialogResult.ok) {
+                const planes = [Plane.XY, Plane.YZ, Plane.ZX];
+                view.workplane = planes[vm.planes.selectedIndexes[0]];
+            }
+        });
+    }
+
+    private ui(vm: WorkingPlaneViewModel) {
+        return div(
+            ...Property.getProperties(vm).map((x) => {
+                const value = (vm as any)[x.name];
+                if (value instanceof SelectableItems) {
+                    return new RadioGroup(I18n.translate(x.display), value);
+                }
+                return "";
+            }),
+        );
+    }
+}
+
+@command({
+    key: "workingPlane.alignToPlane",
+    icon: "icon-alignWorkingPlane",
+})
+export class AlignToPlane implements ICommand {
+    async execute(application: IApplication): Promise<void> {
+        const view = application.activeView;
+        if (!view) return;
+        view.document.selection.clearSelection();
+        const controller = new AsyncController();
+        const data = await new SelectShapeStep(ShapeType.Face, "prompt.select.faces").execute(
+            view.document,
+            controller,
+        );
+        controller.dispose();
+        if (!data || data.shapes.length === 0) return;
+        view.document.visual.highlighter.clear();
+        const face = data.shapes[0].shape.transformedMul(data.shapes[0].transform) as IFace;
+        const [point, normal] = face.normal(0, 0);
+        face.dispose();
+        let xvec = XYZ.unitX;
+        if (!normal.isParallelTo(XYZ.unitZ)) {
+            xvec = XYZ.unitZ.cross(normal).normalize()!;
+        }
+        view.workplane = new Plane(point, normal, xvec);
+    }
+}
+
+@command({
+    key: "workingPlane.fromSection",
+    icon: "icon-fromSection",
+})
+export class FromSection extends MultistepCommand {
+    protected override executeMainTask() {
+        const curve = this.transformedCurve();
+        const point = this.stepDatas[1].point!;
+
+        const parameter = curve.parameter(point, 1e-3);
+        if (parameter === undefined) return;
+        const direction = curve.d1(parameter).vec.normalize()!;
+        const xvec: XYZ = this.findXVec(direction);
+        const plane = new Plane(point, direction, xvec);
+        const view = this.application.activeView;
+        if (!view) return;
+        view.workplane = plane;
+    }
+
+    private findXVec(direction: XYZ) {
+        let xvec: XYZ;
+        if (direction.isEqualTo(XYZ.unitZ)) {
+            xvec = XYZ.unitX;
+        } else if (direction.isEqualTo(new XYZ(0, 0, -1))) {
+            xvec = XYZ.unitY;
+        } else {
+            xvec = direction.cross(XYZ.unitZ).normalize()!;
+        }
+        return xvec;
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Edge, "prompt.select.edges"),
+            new PointOnCurveStep("prompt.pickFistPoint", this.handlePointData, true),
+        ];
+    }
+
+    private transformedCurve() {
+        const shape = this.stepDatas[0].shapes[0].shape as IEdge;
+        const matrix = shape.matrix.multiply(this.stepDatas[0].shapes[0].transform);
+        const curve = shape.curve.transformed(matrix) as ICurve;
+        this.disposeStack.add(curve);
+        return curve;
+    }
+
+    private readonly handlePointData = () => {
+        const curve = this.transformedCurve();
+        return {
+            curve,
+            dimension: Dimension.D1,
+            preview: (point: XYZ | undefined) => {
+                if (!point) return [];
+                const project = curve.project(point).at(0);
+                return [this.meshPoint(project ?? point)];
+            },
+        };
+    };
+}

package/packages/chili/src/comparers/NumberEqualityComparer.ts

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type IEqualityComparer, Precision } from "chili-core";
+
+export class NumberEqualityComparer implements IEqualityComparer<number> {
+    constructor(readonly tolerance: number = Precision.Distance) {}
+
+    equals(left: number, right: number): boolean {
+        return Math.abs(left - right) < this.tolerance;
+    }
+}

package/packages/chili/src/comparers/XYZEqualityComparer.ts

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type IEqualityComparer, Precision, type XYZ } from "chili-core";
+
+export class XYZEqualityComparer implements IEqualityComparer<XYZ> {
+    constructor(readonly tolerance: number = Precision.Distance) {}
+
+    equals(left: XYZ, right: XYZ): boolean {
+        return left.isEqualTo(right, this.tolerance);
+    }
+}

package/packages/chili/src/comparers/index.ts

@@ -0,0 +1,5 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./NumberEqualityComparer";
+export * from "./XYZEqualityComparer";