chili3d 0.6.1

package/packages/chili/src/commands/create/prism.ts

@@ -0,0 +1,52 @@
+// 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 GeometryNode, type IShape, Precision, ShapeType } from "chili-core";
+import { GeoUtils } from "chili-geo";
+import { PrismNode } from "../../bodys";
+import type { LengthAtAxisSnapData } from "../../snap";
+import { type IStep, LengthAtAxisStep } from "../../step";
+import { SelectShapeStep } from "../../step/selectStep";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.extrude",
+    icon: "icon-prism",
+})
+export class Prism extends CreateCommand {
+    protected override geometryNode(): GeometryNode {
+        const shape = this.transformdFirstShape(this.stepDatas[0], false);
+        const { point, normal } = this.getAxis(shape);
+        const dist = this.stepDatas[1].point!.sub(point).dot(normal);
+        return new PrismNode(this.document, shape, dist);
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Face | ShapeType.Edge | ShapeType.Wire, "prompt.select.shape"),
+            new LengthAtAxisStep("prompt.pickNextPoint", this.getLengthStepData, true),
+        ];
+    }
+
+    private readonly getLengthStepData = (): LengthAtAxisSnapData => {
+        const shape = this.transformdFirstShape(this.stepDatas[0]);
+        const { point, normal } = this.getAxis(shape);
+        return {
+            point,
+            direction: normal,
+            preview: (p) => {
+                if (!p) return [];
+                const dist = p.sub(point).dot(normal);
+                if (Math.abs(dist) < Precision.Float) return [];
+                const vec = normal.multiply(dist);
+                return [this.meshCreatedShape("prism", shape, vec)];
+            },
+        };
+    };
+
+    private getAxis(shape: IShape) {
+        const point = this.stepDatas[0].shapes[0].point!;
+        const normal = GeoUtils.normal(shape as any);
+        return { point, normal };
+    }
+}

package/packages/chili/src/commands/create/pyramid.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, type GeometryNode, type Plane, type XYZ } from "chili-core";
+import { PyramidNode } from "../../bodys";
+import type { LengthAtAxisSnapData } from "../../snap";
+import { type IStep, LengthAtAxisStep } from "../../step";
+import { RectCommandBase } from "./rect";
+
+@command({
+    key: "create.pyramid",
+    icon: "icon-pyramid",
+})
+export class Pyramid extends RectCommandBase {
+    protected override getSteps(): IStep[] {
+        const steps = super.getSteps();
+        const third = new LengthAtAxisStep("prompt.pickNextPoint", this.getHeightStepData);
+        return [...steps, third];
+    }
+
+    private readonly getHeightStepData = (): LengthAtAxisSnapData => {
+        const plane = this.stepDatas[1].plane;
+        if (plane === undefined) {
+            throw new Error("plane is undefined, please report bug");
+        }
+        const point = this.stepDatas[1].point!.add(this.stepDatas[0].point!).multiply(0.5);
+        return {
+            point,
+            direction: plane.normal,
+            preview: this.previewPyramid,
+        };
+    };
+
+    private readonly previewPyramid = (end: XYZ | undefined) => {
+        if (!end) {
+            return this.previewRect(this.stepDatas[1].point);
+        }
+
+        const data = this.rectDataFromTwoSteps();
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(this.stepDatas[1].point!),
+            this.meshCreatedShape("pyramid", data.plane, data.dx, data.dy, this.getHeight(data.plane, end)),
+        ];
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const rect = this.rectDataFromTwoSteps();
+        const dz = this.getHeight(rect.plane, this.stepDatas[2].point!);
+        return new PyramidNode(this.document, rect.plane, rect.dx, rect.dy, dz);
+    }
+
+    private getHeight(plane: Plane, point: XYZ): number {
+        return point.sub(plane.origin).dot(plane.normal);
+    }
+}

package/packages/chili/src/commands/create/rect.ts

@@ -0,0 +1,105 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Config, command, type GeometryNode, MathUtils, Plane, Property, type XYZ } from "chili-core";
+import { ViewUtils } from "chili-vis";
+import { RectNode } from "../../bodys";
+import type { SnapLengthAtPlaneData, SnapResult } from "../../snap";
+import { type IStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+export interface RectData {
+    plane: Plane;
+    dx: number;
+    dy: number;
+    p1: XYZ;
+    p2: XYZ;
+}
+
+export namespace RectData {
+    export function get(atPlane: Plane, start: XYZ, end: XYZ): RectData {
+        const plane = new Plane(start, atPlane.normal, atPlane.xvec);
+        const vector = end.sub(start);
+        const dx = vector.dot(plane.xvec);
+        const dy = vector.dot(plane.yvec);
+        return { plane, dx, dy, p1: start, p2: end };
+    }
+}
+
+export abstract class RectCommandBase extends CreateCommand {
+    protected getSteps(): IStep[] {
+        return [
+            new PointStep("prompt.pickFistPoint"),
+            new LengthAtPlaneStep("prompt.pickNextPoint", this.nextSnapData),
+        ];
+    }
+
+    private readonly nextSnapData = (): SnapLengthAtPlaneData => {
+        const { point, view } = this.stepDatas[0];
+        return {
+            point: () => point!,
+            preview: this.previewRect,
+            plane: (tmp: XYZ | undefined) => this.findPlane(view, point!, tmp),
+            validator: this.handleValid,
+            prompt: (snaped: SnapResult) => {
+                const data = this.rectDataFromTemp(snaped.point!);
+                return `${data.dx.toFixed(2)}, ${data.dy.toFixed(2)}`;
+            },
+        };
+    };
+
+    private readonly handleValid = (end: XYZ) => {
+        const data = this.rectDataFromTemp(end);
+        return data !== undefined && !MathUtils.anyEqualZero(data.dx, data.dy);
+    };
+
+    protected previewRect = (end: XYZ | undefined) => {
+        if (end === undefined) return [this.meshPoint(this.stepDatas[0].point!)];
+        const { plane, dx, dy } = this.rectDataFromTemp(end);
+
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(end),
+            this.meshCreatedShape("rect", plane, dx, dy),
+        ];
+    };
+
+    protected rectDataFromTemp(tmp: XYZ): RectData {
+        const { view, point } = this.stepDatas[0];
+        const plane = Config.instance.dynamicWorkplane
+            ? ViewUtils.raycastClosestPlane(view, point!, tmp)
+            : this.stepDatas[0].view.workplane.translateTo(point!);
+        return RectData.get(plane, point!, tmp);
+    }
+
+    protected rectDataFromTwoSteps() {
+        let rect: RectData;
+        if (this.stepDatas[1].plane) {
+            rect = RectData.get(this.stepDatas[1].plane, this.stepDatas[0].point!, this.stepDatas[1].point!);
+        } else {
+            rect = this.rectDataFromTemp(this.stepDatas[1].point!);
+        }
+        return rect;
+    }
+}
+
+@command({
+    key: "create.rect",
+    icon: "icon-rect",
+})
+export class Rect extends RectCommandBase {
+    @Property.define("option.command.isFace")
+    public get isFace() {
+        return this.getPrivateValue("isFace", false);
+    }
+    public set isFace(value: boolean) {
+        this.setProperty("isFace", value);
+    }
+
+    protected override geometryNode(): GeometryNode {
+        const { plane, dx, dy } = this.rectDataFromTwoSteps();
+        const node = new RectNode(this.document, plane, dx, dy);
+        node.isFace = this.isFace;
+        return node;
+    }
+}

package/packages/chili/src/commands/create/revolve.ts

@@ -0,0 +1,62 @@
+// 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 GeometryNode,
+    ICurve,
+    type IEdge,
+    type ILine,
+    type IShape,
+    type IShapeFilter,
+    Line,
+    Property,
+    ShapeType,
+} from "chili-core";
+import { RevolvedNode } from "../../bodys";
+import type { IStep } from "../../step";
+import { SelectShapeStep } from "../../step/selectStep";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.revol",
+    icon: "icon-revolve",
+})
+export class Revolve extends CreateCommand {
+    @Property.define("common.angle")
+    public get angle() {
+        return this.getPrivateValue("angle", 360);
+    }
+    public set angle(value: number) {
+        this.setProperty("angle", value);
+    }
+
+    protected override geometryNode(): GeometryNode {
+        const shape = this.transformdFirstShape(this.stepDatas[0], false);
+        const edge = (this.stepDatas[1].shapes[0].shape as IEdge).curve.basisCurve as ILine;
+        const transform = this.stepDatas[1].shapes[0].transform;
+        const axis = new Line(transform.ofPoint(edge.value(0)), transform.ofVector(edge.direction));
+        return new RevolvedNode(this.document, shape, axis, this.angle);
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Face | ShapeType.Wire, "prompt.select.shape"),
+            new SelectShapeStep(ShapeType.Edge, "prompt.select.edges", {
+                shapeFilter: new LineFilter(),
+                keepSelection: true,
+            }),
+        ];
+    }
+}
+
+class LineFilter implements IShapeFilter {
+    allow(shape: IShape): boolean {
+        if (shape.shapeType === ShapeType.Edge) {
+            const edge = shape as IEdge;
+            const curve = edge.curve.basisCurve;
+            return ICurve.isLine(curve);
+        }
+        return false;
+    }
+}

package/packages/chili/src/commands/create/section.ts

@@ -0,0 +1,31 @@
+// 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, I18n, ShapeType, VisualState } from "chili-core";
+import type { IStep } from "../../step";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "create.section",
+    icon: "icon-section",
+})
+export class Section extends MultistepCommand {
+    protected override executeMainTask() {
+        const shape = this.transformdFirstShape(this.stepDatas[0]);
+        const path = this.transformdFirstShape(this.stepDatas[1]);
+        const section = shape.section(path);
+        const node = new EditableShapeNode(this.document, I18n.translate("command.create.section"), section);
+        this.document.modelManager.rootNode.add(node);
+        this.document.visual.update();
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                selectedState: VisualState.faceTransparent,
+            }),
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", { keepSelection: true }),
+        ];
+    }
+}

package/packages/chili/src/commands/create/sphere.ts

@@ -0,0 +1,48 @@
+// 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 GeometryNode, Precision, XYZ } from "chili-core";
+import { SphereNode } from "../../bodys";
+import type { SnapLengthAtPlaneData } from "../../snap";
+import { type IStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.sphere",
+    icon: "icon-sphere",
+})
+export class Sphere extends CreateCommand {
+    protected override getSteps(): IStep[] {
+        const centerStep = new PointStep("prompt.pickCircleCenter");
+        const radiusStep = new LengthAtPlaneStep("prompt.pickRadius", this.getRadiusData);
+        return [centerStep, radiusStep];
+    }
+
+    private readonly getRadiusData = (): SnapLengthAtPlaneData => {
+        const point = this.stepDatas[0].point!;
+        return {
+            point: () => point,
+            preview: this.previewSphere,
+            plane: () => this.stepDatas[0].view.workplane.translateTo(point),
+            validator: (p: XYZ) => p.distanceTo(point) > Precision.Distance,
+        };
+    };
+
+    private readonly previewSphere = (end: XYZ | undefined) => {
+        if (!end) {
+            return [this.meshPoint(this.stepDatas[0].point!)];
+        }
+
+        const radius = this.stepDatas[0].point?.distanceTo(end)!;
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshCreatedShape("circle", XYZ.unitZ, this.stepDatas[0].point!, radius),
+            this.meshCreatedShape("circle", XYZ.unitY, this.stepDatas[0].point!, radius),
+        ];
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const radius = this.stepDatas[0].point!.distanceTo(this.stepDatas[1].point!);
+        return new SphereNode(this.document, this.stepDatas[0].point!, radius);
+    }
+}

package/packages/chili/src/commands/create/sweep.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, type GeometryNode, type IWire, Property, ShapeType } from "chili-core";
+import { SweepedNode } from "../../bodys";
+import type { IStep } from "../../step";
+import { SelectShapeStep } from "../../step/selectStep";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.sweep",
+    icon: "icon-sweep",
+})
+export class Sweep extends CreateCommand {
+    @Property.define("option.command.isRoundCorner")
+    get round() {
+        return this.getPrivateValue("round", false);
+    }
+
+    set round(value: boolean) {
+        this.setProperty("round", value);
+    }
+
+    protected override geometryNode(): GeometryNode {
+        const path = this.transformdFirstShape(this.stepDatas[0], false) as IWire;
+        const shapes = this.transformdShapes(this.stepDatas[1], false) as IWire[];
+        return new SweepedNode(this.document, shapes, path, this.round);
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Wire, "prompt.select.path"),
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Wire, "prompt.select.section", {
+                keepSelection: true,
+                multiple: true,
+            }),
+        ];
+    }
+}

package/packages/chili/src/commands/create/thickSolid.ts

@@ -0,0 +1,50 @@
+// 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, I18n, Property, PubSub, ShapeType, Transaction } from "chili-core";
+import { type IStep, SelectShapeStep } from "../../step";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "create.thickSolid",
+    icon: "icon-thickSolid",
+})
+export class ThickSolidCommand extends MultistepCommand {
+    @Property.define("option.command.thickness")
+    get thickness() {
+        return this.getPrivateValue("thickness", 10);
+    }
+    set thickness(value: number) {
+        this.setProperty("thickness", value);
+    }
+
+    protected override executeMainTask(): void {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            this.stepDatas[0].shapes.forEach((x) => {
+                const subShape = this.application.shapeFactory.makeThickSolidBySimple(
+                    x.shape,
+                    this.thickness,
+                );
+                if (!subShape.isOk) {
+                    PubSub.default.pub("showToast", "toast.converter.error");
+                    return;
+                }
+                const model = new EditableShapeNode(
+                    this.document,
+                    I18n.translate("command.create.thickSolid"),
+                    subShape,
+                );
+
+                const node = x.owner.node;
+                model.transform = node.transform;
+                node.parent!.insertAfter(node, model);
+            });
+            this.document.visual.update();
+            PubSub.default.pub("showToast", "toast.success");
+        });
+    }
+
+    protected override getSteps(): IStep[] {
+        return [new SelectShapeStep(ShapeType.Face, "prompt.select.faces", { multiple: true })];
+    }
+}

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

@@ -0,0 +1,26 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Act, command, I18n, type IApplication, type ICommand } from "chili-core";
+
+let index = 0;
+
+@command({
+    key: "act.alignCamera",
+    icon: "icon-act",
+})
+export class ActAlignCameraCommand implements ICommand {
+    async execute(application: IApplication): Promise<void> {
+        const view = application.activeView;
+        if (!view) return;
+
+        view.document.acts.push(
+            new Act(
+                `${I18n.translate("ribbon.group.act")} ${index++}`,
+                view.cameraController.cameraPosition,
+                view.cameraController.cameraTarget,
+                view.cameraController.cameraUp,
+            ),
+        );
+    }
+}

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

@@ -0,0 +1,41 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type GeometryNode, Property, Transaction } from "chili-core";
+import { MultistepCommand } from "./multistepCommand";
+
+const count = 1;
+
+export abstract class CreateCommand extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const node = this.geometryNode();
+            this.document.modelManager.addNode(node);
+            this.document.visual.update();
+        });
+    }
+
+    protected abstract geometryNode(): GeometryNode;
+}
+
+export abstract class CreateNodeCommand extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            this.document.modelManager.addNode(this.getNode());
+            this.document.visual.update();
+        });
+    }
+
+    protected abstract getNode(): GeometryNode;
+}
+
+export abstract class CreateFaceableCommand extends CreateCommand {
+    protected _isFace: boolean = false;
+    @Property.define("option.command.isFace")
+    public get isFace() {
+        return this._isFace;
+    }
+    public set isFace(value: boolean) {
+        this.setProperty("isFace", value);
+    }
+}

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

@@ -0,0 +1,38 @@
+// 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 INode, PubSub, Transaction } from "chili-core";
+import { GetOrSelectNodeStep, type IStep } from "../step";
+import { MultistepCommand } from "./multistepCommand";
+
+@command({
+    key: "modify.deleteNode",
+    icon: "icon-delete",
+})
+export class Delete extends MultistepCommand {
+    protected override executeMainTask(): void {
+        const nodes: INode[] | undefined = this.stepDatas[0].nodes;
+        if (!nodes || nodes.length === 0) {
+            PubSub.default.pub("showToast", "toast.select.noSelected");
+            return;
+        }
+
+        if (
+            this.document.modelManager.currentNode &&
+            nodes.includes(this.document.modelManager.currentNode)
+        ) {
+            this.document.modelManager.currentNode = this.document.modelManager.rootNode;
+        }
+
+        this.document.selection.clearSelection();
+        Transaction.execute(this.document, "delete", () => {
+            nodes.forEach((model) => model.parent?.remove(model));
+        });
+        this.document.visual.update();
+        PubSub.default.pub("showToast", "toast.delete{0}Objects", nodes.length);
+    }
+
+    protected override getSteps(): IStep[] {
+        return [new GetOrSelectNodeStep("prompt.select.models", { multiple: true })];
+    }
+}

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

@@ -0,0 +1,18 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, FolderNode, type IApplication, type ICommand } from "chili-core";
+
+let index = 1;
+
+@command({
+    key: "create.folder",
+    icon: "icon-folder-plus",
+})
+export class NewFolder implements ICommand {
+    async execute(app: IApplication): Promise<void> {
+        const document = app.activeView?.document!;
+        const folder = new FolderNode(document, `Folder${index++}`);
+        document.modelManager.addNode(folder);
+    }
+}

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

@@ -0,0 +1,97 @@
+// 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,
+    Combobox,
+    command,
+    download,
+    I18n,
+    type IApplication,
+    type ICommand,
+    Property,
+    PubSub,
+    readFilesAsync,
+} from "chili-core";
+import { SelectNodeStep } from "../step";
+import { importFiles } from "../utils";
+
+@command({
+    key: "file.import",
+    icon: "icon-import",
+})
+export class Import implements ICommand {
+    async execute(application: IApplication): Promise<void> {
+        const extenstions = application.dataExchange.importFormats().join(",");
+        const files = await readFilesAsync(extenstions, true);
+        if (!files.isOk || files.value.length === 0) {
+            alert(files.error);
+            return;
+        }
+        importFiles(application, files.value);
+    }
+}
+
+@command({
+    key: "file.export",
+    icon: "icon-export",
+})
+export class Export extends CancelableCommand {
+    @Property.define("file.format")
+    public get formats() {
+        return this.getPrivateValue("formats", this.initCombobox());
+    }
+    public set formats(value: Combobox<string>) {
+        this.setProperty("formats", value);
+    }
+
+    private initCombobox() {
+        const box = new Combobox<string>();
+        box.items.push(...this.application.dataExchange.exportFormats());
+        return box;
+    }
+
+    protected async executeAsync() {
+        const nodes = await this.selectNodesAsync();
+        if (!nodes || nodes.length === 0) {
+            PubSub.default.pub("showToast", "toast.select.noSelected");
+            return;
+        }
+
+        PubSub.default.pub(
+            "showPermanent",
+            async () => {
+                const format = this.formats.selectedItem;
+                if (format === undefined) return;
+
+                const data = await this.application.dataExchange.export(format, nodes);
+                if (!data) return;
+
+                let suffix = format;
+
+                if (suffix === ".stl binary") {
+                    suffix = ".stl";
+                } else if (suffix === ".ply binary") {
+                    suffix = ".ply";
+                }
+
+                PubSub.default.pub("showToast", "toast.downloading");
+                download(data, `${nodes[0].name}${suffix}`);
+            },
+            "toast.excuting{0}",
+            I18n.translate("command.file.export"),
+        );
+    }
+
+    private async selectNodesAsync() {
+        this.controller = new AsyncController();
+        const step = new SelectNodeStep("prompt.select.models", { multiple: true, keepSelection: true });
+        const data = await step.execute(this.application.activeView?.document!, this.controller);
+        if (!data?.nodes) {
+            PubSub.default.pub("showToast", "prompt.select.noModelSelected");
+            return undefined;
+        }
+        return data.nodes;
+    }
+}