chili3d 0.6.1

package/packages/chili/src/commands/application/performanceTest.ts

@@ -0,0 +1,64 @@
+// 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 IApplication,
+    type ICommand,
+    type IDocument,
+    type Material,
+    Plane,
+    XYZ,
+} from "chili-core";
+
+export abstract class PerformanceTestCommand implements ICommand {
+    protected size = 10;
+    protected gap = 1;
+    protected rowCols = 20;
+
+    async execute(app: IApplication): Promise<void> {
+        const document = await app.newDocument("OCC Performace Test");
+
+        const start = performance.now();
+        const distance = this.gap + this.size;
+        for (let x = 0; x < this.rowCols; x++) {
+            for (let y = 0; y < this.rowCols; y++) {
+                for (let z = 0; z < this.rowCols; z++) {
+                    const position = XYZ.zero
+                        .add(XYZ.unitX.multiply(x * distance))
+                        .add(XYZ.unitY.multiply(y * distance))
+                        .add(XYZ.unitZ.multiply(z * distance));
+                    this.createShape(document, document.modelManager.materials.at(0)!, position);
+                }
+            }
+        }
+        document.visual.update();
+        alert(
+            `Create ${this.rowCols * this.rowCols * this.rowCols} shapes, Time: ${performance.now() - start} ms`,
+        );
+    }
+
+    protected abstract createShape(document: IDocument, material: Material, position: XYZ): void;
+}
+
+@command({
+    key: "test.performance",
+    icon: "icon-performance",
+})
+export class OccPerformanceTestCommand extends PerformanceTestCommand {
+    private index = 1;
+    shapes: any[] = [];
+
+    protected override createShape(document: IDocument, material: Material, position: XYZ): void {
+        const plane = Plane.XY.translateTo(position);
+        const box = document.application.shapeFactory.box(
+            plane,
+            this.size * Math.random(),
+            this.size * Math.random(),
+            this.size * Math.random(),
+        ).value;
+        const node = new EditableShapeNode(document, `box ${this.index++}`, box, material.id);
+        document.modelManager.addNode(node);
+    }
+}

package/packages/chili/src/commands/application/saveDocument.ts

@@ -0,0 +1,24 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { command, I18n, type IApplication, type ICommand, PubSub } from "chili-core";
+
+@command({
+    key: "doc.save",
+    icon: "icon-save",
+    isApplicationCommand: true,
+})
+export class SaveDocument implements ICommand {
+    async execute(app: IApplication): Promise<void> {
+        if (!app.activeView?.document) return;
+        PubSub.default.pub(
+            "showPermanent",
+            async () => {
+                await app.activeView?.document.save();
+                PubSub.default.pub("showToast", "toast.document.saved");
+            },
+            "toast.excuting{0}",
+            I18n.translate("command.doc.save"),
+        );
+    }
+}

package/packages/chili/src/commands/application/toFile.ts

@@ -0,0 +1,35 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    command,
+    DOCUMENT_FILE_EXTENSION,
+    download,
+    I18n,
+    type IApplication,
+    type ICommand,
+    PubSub,
+} from "chili-core";
+
+@command({
+    key: "doc.saveToFile",
+    icon: "icon-download",
+})
+export class SaveDocumentToFile implements ICommand {
+    async execute(app: IApplication): Promise<void> {
+        if (!app.activeView?.document) return;
+        PubSub.default.pub(
+            "showPermanent",
+            async () => {
+                await new Promise((r) => {
+                    setTimeout(r, 100);
+                });
+                const s = app.activeView?.document.serialize();
+                PubSub.default.pub("showToast", "toast.downloading");
+                download([JSON.stringify(s)], `${app.activeView?.document.name}${DOCUMENT_FILE_EXTENSION}`);
+            },
+            "toast.excuting{0}",
+            I18n.translate("command.doc.saveToFile"),
+        );
+    }
+}

package/packages/chili/src/commands/application/toggleDynamicWorkplane.ts

@@ -0,0 +1,15 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Binding, Config, command, type IApplication, type ICommand } from "chili-core";
+
+@command({
+    key: "workingPlane.toggleDynamic",
+    toggle: new Binding(Config.instance, "dynamicWorkplane"),
+    icon: "icon-dynamicPlane",
+})
+export class ToggleDynamicWorkplaneCommand implements ICommand {
+    async execute(_app: IApplication): Promise<void> {
+        Config.instance.dynamicWorkplane = !Config.instance.dynamicWorkplane;
+    }
+}

package/packages/chili/src/commands/application/wechatGroup.ts

@@ -0,0 +1,42 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { br, div, img, label } from "chili-controls";
+import { command, type IApplication, type ICommand, PubSub } from "chili-core";
+
+@command({
+    key: "wechat.group",
+    icon: "icon-qrcode",
+    isApplicationCommand: true,
+})
+export class WeChatGroup implements ICommand {
+    async execute(app: IApplication): Promise<void> {
+        PubSub.default.pub("showDialog", "command.wechat.group", this.ui());
+    }
+
+    private ui() {
+        return div(
+            label(
+                {
+                    style: {
+                        fontSize: "14px",
+                        display: "block",
+                        textAlign: "center",
+                        marginBottom: "10px",
+                        opacity: "0.75",
+                    },
+                },
+                "群聊人数已超过200人，只可通过邀请进入群聊",
+                br(),
+                "入群请先添加个人微信：oOxianOo",
+            ),
+            img({
+                width: 360,
+                src: "images/wechat.jpg",
+                style: {
+                    borderRadius: "10px",
+                },
+            }),
+        );
+    }
+}

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

@@ -0,0 +1,109 @@
+// 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 IShape,
+    PubSub,
+    type Result,
+    ShapeNode,
+    ShapeType,
+    Transaction,
+    VisualState,
+} from "chili-core";
+import { BooleanNode } from "../bodys/boolean";
+import { type IStep, SelectShapeStep } from "../step";
+import { MultistepCommand } from "./multistepCommand";
+
+export abstract class BooleanOperate extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, "boolean", () => {
+            const shape1 = this.transformdFirstShape(this.stepDatas[0]);
+            const shape2 = this.transformdShapes(this.stepDatas[1]);
+            const booleanType = this.getBooleanOperateType();
+
+            const booleanShape = this.getBooleanShape(booleanType, shape1, shape2);
+            if (!booleanShape.isOk) {
+                PubSub.default.pub("showToast", "error.default:{0}", "boolean failed");
+                return;
+            }
+            const node = new BooleanNode(this.document, booleanShape.value);
+            this.document.modelManager.rootNode.add(node);
+            this.stepDatas.forEach((x) => {
+                x.nodes?.forEach((n) => n.parent?.remove(n));
+            });
+            this.document.visual.update();
+        });
+    }
+
+    private getBooleanShape(
+        type: "common" | "cut" | "fuse",
+        shape1: IShape,
+        tools: IShape[],
+    ): Result<IShape> {
+        switch (type) {
+            case "common":
+                return this.application.shapeFactory.booleanCommon([shape1], tools);
+            case "cut":
+                return this.application.shapeFactory.booleanCut([shape1], tools);
+            default:
+                return this.application.shapeFactory.booleanFuse([shape1], tools);
+        }
+    }
+
+    protected abstract getBooleanOperateType(): "common" | "cut" | "fuse";
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                nodeFilter: { allow: (node) => node instanceof ShapeNode },
+            }),
+            new SelectShapeStep(ShapeType.Shape, "prompt.select.shape", {
+                nodeFilter: {
+                    allow: (node) => {
+                        if (!(node instanceof ShapeNode)) {
+                            return false;
+                        }
+
+                        return !this.stepDatas[0].nodes
+                            ?.map((x) => (x as ShapeNode).shape.value)
+                            .includes(node.shape.value);
+                    },
+                },
+                multiple: true,
+                keepSelection: true,
+                selectedState: VisualState.faceTransparent,
+            }),
+        ];
+    }
+}
+
+@command({
+    key: "boolean.common",
+    icon: "icon-booleanCommon",
+})
+export class BooleanCommon extends BooleanOperate {
+    protected override getBooleanOperateType(): "common" | "cut" | "fuse" {
+        return "common";
+    }
+}
+
+@command({
+    key: "boolean.cut",
+    icon: "icon-booleanCut",
+})
+export class BooleanCut extends BooleanOperate {
+    protected override getBooleanOperateType(): "common" | "cut" | "fuse" {
+        return "cut";
+    }
+}
+
+@command({
+    key: "boolean.join",
+    icon: "icon-booleanFuse",
+})
+export class BooleanFuse extends BooleanOperate {
+    protected override getBooleanOperateType(): "common" | "cut" | "fuse" {
+        return "fuse";
+    }
+}

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

@@ -0,0 +1,110 @@
+// 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,
+    Plane,
+    PlaneAngle,
+    Precision,
+    type ShapeMeshData,
+    type XYZ,
+} from "chili-core";
+import { ArcNode } from "../../bodys/arc";
+import { Dimension, type SnapLengthAtPlaneData } from "../../snap";
+import { AngleStep, type IStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.arc",
+    icon: "icon-arc",
+})
+export class Arc extends CreateCommand {
+    private _planeAngle: PlaneAngle | undefined;
+
+    getSteps(): IStep[] {
+        return [
+            new PointStep("prompt.pickCircleCenter"),
+            new LengthAtPlaneStep("prompt.pickRadius", this.getRadiusData),
+            new AngleStep(
+                "prompt.pickNextPoint",
+                () => this.stepDatas[0].point!,
+                () => this.stepDatas[1].point!,
+                this.getAngleData,
+            ),
+        ];
+    }
+
+    private readonly getRadiusData = (): 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 getAngleData = () => {
+        const [center, p1] = [this.stepDatas[0].point!, this.stepDatas[1].point!];
+        const plane = this.stepDatas[1].plane ?? this.findPlane(this.stepDatas[1].view, center, p1);
+        const points: ShapeMeshData[] = [this.meshPoint(center), this.meshPoint(p1)];
+        this._planeAngle = new PlaneAngle(new Plane(center, plane.normal, p1.sub(center)));
+        return {
+            dimension: Dimension.D1D2,
+            preview: (point: XYZ | undefined) => this.anglePreview(point, center, p1, points),
+            plane: () => plane,
+            validators: [this.angleValidator(center, plane)],
+        };
+    };
+
+    private anglePreview(
+        point: XYZ | undefined,
+        center: XYZ,
+        p1: XYZ,
+        points: ShapeMeshData[],
+    ): ShapeMeshData[] {
+        point = point ?? p1;
+        this._planeAngle!.movePoint(point);
+        const result = [...points];
+        if (Math.abs(this._planeAngle!.angle) > Precision.Angle) {
+            result.push(
+                this.meshCreatedShape(
+                    "arc",
+                    this._planeAngle!.plane.normal,
+                    center,
+                    p1,
+                    this._planeAngle!.angle,
+                ),
+            );
+        }
+        return result;
+    }
+
+    private angleValidator(center: XYZ, plane: Plane) {
+        return (p: XYZ) =>
+            p.distanceTo(center) >= Precision.Distance && !p.sub(center).isParallelTo(plane.normal);
+    }
+
+    protected override geometryNode(): GeometryNode {
+        const [p0, p1] = [this.stepDatas[0].point!, this.stepDatas[1].point!];
+        const plane = this.stepDatas[1].plane ?? this.findPlane(this.stepDatas[1].view, p0, p1);
+        this._planeAngle?.movePoint(this.stepDatas[2].point!);
+        return new ArcNode(this.document, plane.normal, p0, p1, this._planeAngle!.angle);
+    }
+
+    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)),
+        ];
+    };
+}

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

@@ -0,0 +1,116 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    AsyncController,
+    command,
+    EdgeMeshData,
+    EditableShapeNode,
+    type GeometryNode,
+    I18n,
+    LineType,
+    Precision,
+    type ShapeMeshData,
+    VisualConfig,
+    type XYZ,
+} from "chili-core";
+import { Dimension, type PointSnapData, type SnapResult } from "../../snap";
+import { type IStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.bezier",
+    icon: "icon-bezier",
+})
+export class BezierCommand extends CreateCommand {
+    protected override geometryNode(): GeometryNode {
+        const bezier = this.application.shapeFactory.bezier(this.stepDatas.map((x) => x.point!));
+        return new EditableShapeNode(this.document, I18n.translate("command.create.bezier"), bezier.value);
+    }
+
+    protected override async executeSteps() {
+        const steps = this.getSteps();
+        let firstStep = true;
+        while (true) {
+            const step = firstStep ? steps[0] : steps[1];
+            if (firstStep) firstStep = false;
+            this.controller = new AsyncController();
+            const data = await step.execute(this.document, this.controller);
+            if (data === undefined) {
+                return this.controller.result?.status === "success";
+            }
+            this.stepDatas.push(data);
+            if (this.isClose(data)) {
+                return true;
+            }
+        }
+    }
+
+    private isClose(data: SnapResult) {
+        console.log(this.stepDatas[0].point!.distanceTo(data.point!));
+        return (
+            this.stepDatas.length > 1 &&
+            this.stepDatas[0].point!.distanceTo(data.point!) <= Precision.Distance
+        );
+    }
+
+    protected override getSteps(): IStep[] {
+        const firstStep = new PointStep("prompt.pickFistPoint");
+        const secondStep = new PointStep("prompt.pickNextPoint", this.getNextData);
+        return [firstStep, secondStep];
+    }
+
+    private readonly getNextData = (): PointSnapData => {
+        return {
+            refPoint: () => this.stepDatas.at(-1)!.point!,
+            dimension: Dimension.D1D2D3,
+            validator: this.validator,
+            preview: this.preview,
+            featurePoints: [
+                {
+                    point: this.stepDatas.at(0)!.point!,
+                    prompt: I18n.translate("prompt.polygon.close"),
+                    when: () => this.stepDatas.length > 2,
+                },
+            ],
+        };
+    };
+
+    private readonly preview = (point: XYZ | undefined): ShapeMeshData[] => {
+        const ps: ShapeMeshData[] = this.stepDatas.map((data) => this.meshPoint(data.point!));
+        const points = this.stepDatas.map((data) => data.point) as XYZ[];
+        if (point) {
+            points.push(point);
+        }
+        if (points.length > 1) {
+            ps.push(...this.previewLines(points));
+            ps.push(this.meshCreatedShape("bezier", points));
+        }
+
+        return ps;
+    };
+
+    private readonly previewLines = (points: XYZ[]): ShapeMeshData[] => {
+        if (points.length < 2) {
+            return [];
+        }
+        const res: ShapeMeshData[] = [];
+        for (let i = 1; i < points.length; i++) {
+            res.push(this.meshHandle(points[i - 1], points[i]));
+        }
+        return res;
+    };
+
+    protected meshHandle(start: XYZ, end: XYZ) {
+        return EdgeMeshData.from(start, end, VisualConfig.temporaryEdgeColor, LineType.Dash);
+    }
+
+    private readonly validator = (point: XYZ): boolean => {
+        for (const data of this.stepDatas) {
+            if (point.distanceTo(data.point!) < 0.001) {
+                return false;
+            }
+        }
+        return true;
+    };
+}

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

@@ -0,0 +1,59 @@
+// 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, Precision, type XYZ } from "chili-core";
+import { BoxNode } from "../../bodys";
+import type { LengthAtAxisSnapData } from "../../snap";
+import { type IStep, LengthAtAxisStep } from "../../step";
+import { RectCommandBase } from "./rect";
+
+@command({
+    key: "create.box",
+    icon: "icon-box",
+})
+export class Box 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");
+        }
+        return {
+            point: this.stepDatas[1].point!,
+            direction: plane.normal,
+            preview: this.previewBox,
+        };
+    };
+
+    private readonly previewBox = (end: XYZ | undefined) => {
+        if (!end) {
+            return this.previewRect(this.stepDatas[1].point);
+        }
+
+        const { plane, dx, dy } = this.rectDataFromTwoSteps();
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(this.stepDatas[1].point!),
+            this.meshCreatedShape("box", plane, dx, dy, this.getHeight(plane, end)),
+        ];
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const rect = this.rectDataFromTwoSteps();
+        const dz = this.getHeight(rect.plane, this.stepDatas[2].point!);
+        return new BoxNode(this.document, rect.plane, rect.dx, rect.dy, dz);
+    }
+
+    private getHeight(plane: Plane, point: XYZ): number {
+        const h = point.sub(this.stepDatas[1].point!).dot(plane.normal);
+        if (Math.abs(h) < Precision.Distance) {
+            return h < 0 ? -0.00001 : 0.00001;
+        }
+        return h;
+    }
+}

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

@@ -0,0 +1,54 @@
+// 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, type XYZ } from "chili-core";
+import { CircleNode } from "../../bodys";
+import type { SnapLengthAtPlaneData } from "../../snap";
+import { type IStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateFaceableCommand } from "../createCommand";
+
+@command({
+    key: "create.circle",
+    icon: "icon-circle",
+})
+export class Circle extends CreateFaceableCommand {
+    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, view } = this.stepDatas[0];
+        return {
+            point: () => point!,
+            preview: this.circlePreview,
+            plane: (tmp: XYZ | undefined) => this.findPlane(view, point!, tmp),
+            validator: (p: XYZ) => {
+                if (p.distanceTo(point!) < Precision.Distance) return false;
+                const plane = this.findPlane(view, point!, p);
+                return p.sub(point!).isParallelTo(plane.normal) === false;
+            },
+        };
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const [p1, p2] = [this.stepDatas[0].point!, this.stepDatas[1].point!];
+        const plane = this.stepDatas[1].plane ?? this.findPlane(this.stepDatas[1].view, p1, p2);
+        const body = new CircleNode(this.document, plane.normal, p1, plane.projectDistance(p1, p2));
+        body.isFace = this.isFace;
+        return body;
+    }
+
+    private readonly circlePreview = (end: XYZ | undefined) => {
+        if (!end) return [this.meshPoint(this.stepDatas[0].point!)];
+
+        const { point, view } = this.stepDatas[0];
+        const plane = this.findPlane(view, point!, end);
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshLine(point!, end),
+            this.meshCreatedShape("circle", plane.normal, point!, plane.projectDistance(point!, end)),
+        ];
+    };
+}