chili3d 0.6.1

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

@@ -0,0 +1,91 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    ComponentNode,
+    command,
+    EditableShapeNode,
+    GroupNode,
+    type IShape,
+    MultiShapeNode,
+    ShapeNode,
+    ShapeType,
+    Transaction,
+} from "chili-core";
+import type { IStep } from "../../step";
+import { GetOrSelectNodeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "modify.explode",
+    icon: "icon-explode",
+})
+export class Explode extends MultistepCommand {
+    protected override getSteps(): IStep[] {
+        return [new GetOrSelectNodeStep("prompt.select.shape", { multiple: true })];
+    }
+
+    protected override executeMainTask() {
+        this.document.selection.clearSelection();
+
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            this.stepDatas[0].nodes?.forEach((x) => {
+                if (x instanceof ShapeNode) {
+                    this.explodeShapeNode(x);
+                } else if (x instanceof ComponentNode) {
+                    this.explodeComponentNode(x);
+                } else if (x instanceof MultiShapeNode) {
+                    this.explodeMultiShapeNode(x);
+                }
+            });
+        });
+
+        this.document.visual.update();
+    }
+
+    private explodeShapeNode(x: ShapeNode) {
+        const subShapes = x.shape.value.iterShape();
+        if (subShapes.length === 1) {
+            const subShapeNode = new EditableShapeNode(this.document, x.name, subShapes[0], x.materialId);
+            subShapeNode.transform = x.transform;
+            x.parent?.insertAfter(x.previousSibling, subShapeNode);
+        } else {
+            this.groupShapes(x, subShapes);
+        }
+
+        x.parent?.remove(x);
+    }
+
+    private groupShapes(node: ShapeNode, subShapes: IShape[]) {
+        const folder = new GroupNode(this.document, node.name);
+        folder.transform = node.transform;
+        node.parent?.insertAfter(node.previousSibling, folder);
+
+        let i = 1;
+        for (const subShape of subShapes) {
+            const name = `${ShapeType.stringValue(subShape.shapeType)} ${i++}`;
+            const subShapeNode = new EditableShapeNode(this.document, name, subShape);
+            folder.add(subShapeNode);
+        }
+    }
+
+    private explodeComponentNode(x: ComponentNode) {
+        for (const node of x.component.nodes) {
+            const newNode = node.clone();
+            newNode.transform = node.transform.multiply(x.transform);
+            x.parent?.insertAfter(x.previousSibling, newNode);
+        }
+
+        x.parent?.remove(x);
+    }
+
+    private explodeMultiShapeNode(x: MultiShapeNode) {
+        for (const shape of x.shapes) {
+            const node = new EditableShapeNode(this.document, x.name, shape.transformed(x.transform));
+            x.parent?.insertAfter(x.previousSibling, node);
+        }
+
+        x.parent?.remove(x);
+        x.shapes.forEach((x) => x.dispose());
+    }
+}

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

@@ -0,0 +1,69 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    command,
+    EditableShapeNode,
+    type ISubEdgeShape,
+    Property,
+    type ShapeNode,
+    ShapeType,
+    Transaction,
+    VisualState,
+} from "chili-core";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "modify.fillet",
+    icon: "icon-fillet",
+})
+export class FilletCommand extends MultistepCommand {
+    @Property.define("circle.radius")
+    get radius() {
+        return this.getPrivateValue("radius", 10);
+    }
+
+    set radius(value: number) {
+        this.setProperty("radius", value);
+    }
+
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const node = this.stepDatas[0].shapes[0].owner.node as ShapeNode;
+            const edges = this.stepDatas.at(-1)!.shapes.map((x) => (x.shape as ISubEdgeShape).index);
+            const filetShape = this.document.application.shapeFactory.fillet(
+                node.shape.value,
+                edges,
+                this.radius,
+            );
+
+            const model = new EditableShapeNode(this.document, node.name, filetShape, node.materialId);
+            model.transform = node.transform;
+            (node.parent ?? this.document.modelManager.rootNode).add(model);
+            node.parent?.remove(node);
+            this.document.visual.update();
+        });
+    }
+
+    protected override getSteps() {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                shapeFilter: {
+                    allow: (shape) => {
+                        return (
+                            shape.shapeType === ShapeType.Solid ||
+                            shape.shapeType === ShapeType.Compound ||
+                            shape.shapeType === ShapeType.CompoundSolid
+                        );
+                    },
+                },
+                selectedState: VisualState.faceTransparent,
+            }),
+            new SelectShapeStep(ShapeType.Edge, "prompt.select.edges", {
+                multiple: true,
+                keepSelection: true,
+            }),
+        ];
+    }
+}

package/packages/chili/src/commands/modify/index.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.
+
+export * from "./array";
+export * from "./break";
+export * from "./brush";
+export * from "./chamfer";
+export * from "./explode";
+export * from "./fillet";
+export * from "./mirror";
+export * from "./move";
+export * from "./removeFeature";
+export * from "./removeSubShapes";
+export * from "./rotate";
+export * from "./split";
+export * from "./trim";

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

@@ -0,0 +1,49 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, Matrix4, Plane, type ShapeMeshData, type XYZ } from "chili-core";
+import { Dimension, type PointSnapData } from "../../snap";
+import { type IStep, PointStep } from "../../step";
+import { TransformedCommand } from "./transformedCommand";
+
+@command({
+    key: "modify.mirror",
+    icon: "icon-mirror",
+})
+export class Mirror extends TransformedCommand {
+    protected override transfrom(point: XYZ): Matrix4 {
+        const center = this.stepDatas[0].point!;
+        const xvec = this.stepDatas[0].view.workplane.normal;
+        const yvec = point.sub(center);
+        const normal = yvec.cross(xvec);
+        const plane = new Plane(center, normal, xvec);
+        return Matrix4.createMirrorWithPlane(plane);
+    }
+
+    getSteps(): IStep[] {
+        const firstStep = new PointStep("prompt.pickFistPoint", undefined, true);
+        const secondStep = new PointStep("prompt.pickNextPoint", this.getSecondPointData, true);
+        return [firstStep, secondStep];
+    }
+
+    private readonly getSecondPointData = (): PointSnapData => {
+        return {
+            refPoint: () => this.stepDatas[0].point!,
+            dimension: Dimension.D1D2,
+            preview: this.mirrorPreview,
+            validator: (p) => {
+                const vec = p.sub(this.stepDatas[0].point!);
+                return vec.length() > 1e-3 && !vec.isParallelTo(this.stepDatas[0].view.workplane.normal);
+            },
+        };
+    };
+
+    private readonly mirrorPreview = (point: XYZ | undefined): ShapeMeshData[] => {
+        const p1 = this.meshPoint(this.stepDatas[0].point!);
+        if (!point) return [p1];
+        const shape = this.transformPreview(point);
+        const offset = point.sub(this.stepDatas[0].point!).normalize()!.multiply(1e6);
+        const line = this.getTempLineData(this.stepDatas[0].point!.sub(offset), point.add(offset));
+        return [p1, shape, line];
+    };
+}

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

@@ -0,0 +1,39 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, Matrix4, type XYZ } from "chili-core";
+import { Dimension, type PointSnapData } from "../../snap";
+import { type IStep, PointStep } from "../../step";
+import { TransformedCommand } from "./transformedCommand";
+
+@command({
+    key: "modify.move",
+    icon: "icon-move",
+})
+export class Move extends TransformedCommand {
+    getSteps(): IStep[] {
+        return [
+            new PointStep("prompt.pickFistPoint", undefined, true),
+            new PointStep("prompt.pickNextPoint", this.getSecondPointData, true),
+        ];
+    }
+
+    private readonly getSecondPointData = (): PointSnapData => {
+        return {
+            refPoint: () => this.stepDatas[0].point!,
+            dimension: Dimension.D1D2D3,
+            preview: this.movePreview,
+        };
+    };
+
+    private readonly movePreview = (point: XYZ | undefined) => {
+        const p1 = this.meshPoint(this.stepDatas[0].point!);
+        if (!point) return [p1];
+        return [p1, this.transformPreview(point), this.getTempLineData(this.stepDatas[0].point!, point)];
+    };
+
+    protected override transfrom(point: XYZ): Matrix4 {
+        const { x, y, z } = point.sub(this.stepDatas[0].point!);
+        return Matrix4.fromTranslation(x, y, z);
+    }
+}

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

@@ -0,0 +1,56 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    command,
+    EditableShapeNode,
+    type IFace,
+    type ShapeNode,
+    ShapeType,
+    Transaction,
+    VisualState,
+} from "chili-core";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "modify.removeFeature",
+    icon: "icon-removeFeature",
+})
+export class RemoveFaceCommand extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const node = this.stepDatas[0].shapes[0].owner.node as ShapeNode;
+            const faces = this.stepDatas.at(-1)!.shapes.map((x) => x.shape as IFace);
+            const filetShape = this.document.application.shapeFactory.removeFeature(node.shape.value, faces);
+
+            const model = new EditableShapeNode(this.document, node.name, filetShape, node.materialId);
+            model.transform = node.transform;
+
+            this.document.modelManager.addNode(model);
+            node.parent?.remove(node);
+            this.document.visual.update();
+        });
+    }
+
+    protected override getSteps() {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                shapeFilter: {
+                    allow: (shape) => {
+                        return (
+                            shape.shapeType === ShapeType.Solid ||
+                            shape.shapeType === ShapeType.Compound ||
+                            shape.shapeType === ShapeType.CompoundSolid
+                        );
+                    },
+                },
+                selectedState: VisualState.faceTransparent,
+            }),
+            new SelectShapeStep(ShapeType.Face, "prompt.select.faces", {
+                multiple: true,
+                keepSelection: true,
+            }),
+        ];
+    }
+}

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

@@ -0,0 +1,44 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, EditableShapeNode, type ShapeNode, ShapeType, Transaction, VisualState } from "chili-core";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "modify.removeShapes",
+    icon: "icon-removeSubShape",
+})
+export class RemoveSubShapesCommand extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const node = this.stepDatas[0].shapes[0].owner.node as ShapeNode;
+            const subShapes = this.stepDatas.at(-1)!.shapes.map((x) => x.shape);
+            const shape = this.document.application.shapeFactory.removeSubShape(node.shape.value, subShapes);
+
+            const model = new EditableShapeNode(this.document, node.name, shape, node.materialId);
+            model.transform = node.transform;
+
+            node.parent?.insertAfter(node.previousSibling, model);
+            node.parent?.remove(node);
+            this.document.visual.update();
+        });
+    }
+
+    protected override getSteps() {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                shapeFilter: {
+                    allow: (shape) => {
+                        return shape.shapeType !== ShapeType.Vertex && shape.shapeType !== ShapeType.Edge;
+                    },
+                },
+                selectedState: VisualState.faceTransparent,
+            }),
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Face, "prompt.select.shape", {
+                multiple: true,
+                keepSelection: true,
+            }),
+        ];
+    }
+}

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

@@ -0,0 +1,112 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, Matrix4, Precision, type ShapeMeshData, type XYZ } from "chili-core";
+import { Dimension, type PointSnapData, type SnapLengthAtPlaneData } from "../../snap";
+import { AngleStep, type IStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { TransformedCommand } from "./transformedCommand";
+
+@command({
+    key: "modify.rotate",
+    icon: "icon-rotate",
+})
+export class Rotate extends TransformedCommand {
+    protected override transfrom(point: XYZ): Matrix4 {
+        const normal = this.stepDatas[1].plane!.normal;
+        const center = this.stepDatas[0].point!;
+        const angle = this.getAngle(point);
+        return Matrix4.fromAxisRad(center, normal, angle);
+    }
+
+    getSteps(): IStep[] {
+        const firstStep = new PointStep("prompt.pickFistPoint", undefined, true);
+        const secondStep = new LengthAtPlaneStep("prompt.pickNextPoint", this.getSecondPointData, true);
+        const thirdStep = new AngleStep(
+            "prompt.pickNextPoint",
+            () => this.stepDatas[0].point!,
+            () => this.stepDatas[1].point!,
+            this.getThirdPointData,
+            true,
+        );
+        return [firstStep, secondStep, thirdStep];
+    }
+
+    private readonly getSecondPointData = (): SnapLengthAtPlaneData => {
+        const { point, view } = this.stepDatas[0];
+        return {
+            point: () => point!,
+            preview: this.circlePreview,
+            plane: (p: XYZ | undefined) => this.findPlane(view, point!, p),
+            validator: (p: XYZ) => {
+                if (p.distanceTo(point!) < Precision.Distance) return false;
+                return p.sub(point!).isParallelTo(this.stepDatas[0].view.workplane.normal) === false;
+            },
+        };
+    };
+
+    private readonly circlePreview = (end: XYZ | undefined) => {
+        const visualCenter = this.meshPoint(this.stepDatas[0].point!);
+        if (!end) return [visualCenter];
+        const { point, view } = this.stepDatas[0];
+        const plane = this.findPlane(view, point!, end);
+        return [
+            visualCenter,
+            this.meshLine(this.stepDatas[0].point!, end),
+            this.meshCreatedShape("circle", plane.normal, point!, plane.projectDistance(point!, end)),
+        ];
+    };
+
+    private readonly getThirdPointData = (): PointSnapData => {
+        return {
+            dimension: Dimension.D1D2,
+            preview: this.anglePreview,
+            plane: () => this.stepDatas[1].plane!,
+            validator: (p) => {
+                return (
+                    p.distanceTo(this.stepDatas[0].point!) > 1e-3 &&
+                    p.distanceTo(this.stepDatas[1].point!) > 1e-3
+                );
+            },
+        };
+    };
+
+    private getAngle(point: XYZ) {
+        const normal = this.stepDatas[1].plane!.normal;
+        const center = this.stepDatas[0].point!;
+        const p1 = this.stepDatas[1].point!;
+        const v1 = p1.sub(center);
+        const v2 = point.sub(center);
+        return v1.angleOnPlaneTo(v2, normal)!;
+    }
+
+    private readonly anglePreview = (point: XYZ | undefined): ShapeMeshData[] => {
+        point = point ?? this.stepDatas[1].point!;
+        const result = [
+            this.transformPreview(point),
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(this.stepDatas[1].point!),
+            this.getRayData(this.stepDatas[1].point!),
+            this.getRayData(point),
+        ];
+
+        const angle = this.getAngle(point);
+        if (Math.abs(angle) > Precision.Angle) {
+            result.push(
+                this.meshCreatedShape(
+                    "arc",
+                    this.stepDatas[1].plane!.normal,
+                    this.stepDatas[0].point!,
+                    this.stepDatas[1].point!,
+                    (angle * 180) / Math.PI,
+                ),
+            );
+        }
+        return result;
+    };
+
+    private getRayData(end: XYZ) {
+        const center = this.stepDatas[0].point!;
+        const rayEnd = center.add(end.sub(center).normalize()!.multiply(1e6));
+        return this.getTempLineData(center, rayEnd);
+    }
+}

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

@@ -0,0 +1,81 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    command,
+    EditableShapeNode,
+    type IEdge,
+    type IVisualObject,
+    ShapeType,
+    Transaction,
+    VisualState,
+} from "chili-core";
+import type { IStep } from "../../step";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "modify.split",
+    icon: "icon-split",
+})
+export class Split extends MultistepCommand {
+    private splitedShape() {
+        const shape1 = this.stepDatas[0].shapes[0].shape;
+        const invertTransform = this.stepDatas[0].shapes[0].transform.invert()!;
+        const edges = this.stepDatas[1].shapes.map((x) =>
+            x.shape.transformedMul(x.transform.multiply(invertTransform)),
+        ) as IEdge[];
+        const result = shape1.split(edges);
+
+        edges.forEach((x) => x.dispose());
+
+        return result;
+    }
+
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const old = this.stepDatas[0].nodes![0];
+            const shape = this.splitedShape();
+            const subShapes = shape.iterShape();
+            if (subShapes.length > 1) {
+                let i = 1;
+                old.parent?.add(
+                    ...subShapes.map((x) => {
+                        const model = new EditableShapeNode(this.document, old.name + i++, x);
+                        model.transform = old.transform;
+                        return model;
+                    }),
+                );
+            } else {
+                const model = new EditableShapeNode(this.document, old.name, shape);
+                model.transform = old.transform;
+                old.parent?.add(model);
+            }
+
+            this.removeModels(
+                this.stepDatas[0].shapes[0].owner,
+                ...this.stepDatas[1].shapes.map((x) => x.owner),
+            );
+            this.document.visual.update();
+        });
+    }
+
+    private removeModels(...shapes: IVisualObject[]) {
+        shapes.forEach((x) => {
+            const model = this.document.visual.context.getNode(x);
+            model?.parent?.remove(model);
+        });
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                selectedState: VisualState.faceTransparent,
+            }),
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Wire | ShapeType.Face, "prompt.select.shape", {
+                multiple: true,
+                keepSelection: true,
+            }),
+        ];
+    }
+}

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

@@ -0,0 +1,100 @@
+// 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,
+    ComponentNode,
+    EdgeMeshData,
+    GeometryNode,
+    LineType,
+    type Matrix4,
+    MeshNode,
+    Property,
+    PubSub,
+    Transaction,
+    VisualConfig,
+    VisualNode,
+    type XYZ,
+} from "chili-core";
+import { MultistepCommand } from "../multistepCommand";
+
+export abstract class TransformedCommand extends MultistepCommand {
+    protected models?: VisualNode[];
+    protected positions?: number[];
+
+    @Property.define("common.clone")
+    get isClone() {
+        return this.getPrivateValue("isClone", false);
+    }
+    set isClone(value: boolean) {
+        this.setProperty("isClone", value);
+    }
+
+    protected abstract transfrom(p2: XYZ): Matrix4;
+
+    protected transformPreview = (point: XYZ): EdgeMeshData => {
+        const transform = this.transfrom(point);
+        const positions = transform.ofPoints(this.positions!);
+        return {
+            position: new Float32Array(positions),
+            lineType: LineType.Solid,
+            color: VisualConfig.defaultEdgeColor,
+            range: [],
+        };
+    };
+
+    private async ensureSelectedModels() {
+        this.models = this.document.selection.getSelectedNodes().filter((x) => x instanceof VisualNode);
+        if (this.models.length > 0) return true;
+
+        this.controller = new AsyncController();
+        this.models = await this.document.selection.pickNode("prompt.select.models", this.controller, true);
+
+        if (this.models.length > 0) return true;
+        if (this.controller.result?.status === "success") {
+            PubSub.default.pub("showToast", "toast.select.noSelected");
+        }
+        return false;
+    }
+
+    protected override async canExcute(): Promise<boolean> {
+        if (!(await this.ensureSelectedModels())) return false;
+
+        this.positions = this.models!.flatMap((model) => {
+            if (model instanceof MeshNode) {
+                return model.mesh.position ? model.transform.ofPoints(model.mesh.position) : [];
+            } else if (model instanceof GeometryNode) {
+                return model.mesh.edges?.position ? model.transform.ofPoints(model.mesh.edges.position) : [];
+            } else if (model instanceof ComponentNode) {
+                return Array.from(BoundingBox.wireframe(model.boundingBox()!).position);
+            }
+            return [];
+        });
+        return true;
+    }
+
+    protected getTempLineData(start: XYZ, end: XYZ) {
+        return EdgeMeshData.from(start, end, VisualConfig.temporaryEdgeColor, LineType.Solid);
+    }
+
+    protected executeMainTask(): void {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const transform = this.transfrom(this.stepDatas.at(-1)!.point!);
+
+            if (this.isClone) {
+                this.models?.forEach((x) => {
+                    const clone = x.clone();
+                    clone.transform = x.transform.multiply(transform);
+                    x.parent?.insertAfter(x, clone);
+                });
+            } else {
+                this.models?.forEach((x) => {
+                    x.transform = x.transform.multiply(transform);
+                });
+            }
+
+            this.document.visual.update();
+        });
+    }
+}