chili3d 0.6.1

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

@@ -0,0 +1,104 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    command,
+    EdgeMeshData,
+    type GeometryNode,
+    LineType,
+    type Plane,
+    Precision,
+    VisualConfig,
+    type XYZ,
+} from "chili-core";
+import { ConeNode } from "../../bodys";
+import type { LengthAtAxisSnapData, SnapLengthAtPlaneData } from "../../snap";
+import { type IStep, LengthAtAxisStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.cone",
+    icon: "icon-cone",
+})
+export class Cone extends CreateCommand {
+    protected override getSteps(): IStep[] {
+        const centerStep = new PointStep("prompt.pickCircleCenter");
+        const radiusStep = new LengthAtPlaneStep("prompt.pickRadius", this.getRadiusData);
+        const third = new LengthAtAxisStep("prompt.pickNextPoint", this.getHeightStepData);
+        return [centerStep, radiusStep, third];
+    }
+
+    private readonly getRadiusData = (): SnapLengthAtPlaneData => {
+        const point = this.stepDatas[0].point!;
+        return {
+            point: () => point,
+            preview: this.circlePreview,
+            plane: (p: XYZ | undefined) => this.findPlane(this.stepDatas[0].view, point, p),
+            validator: (p: XYZ) => {
+                if (p.distanceTo(point) < Precision.Distance) return false;
+                const plane = this.findPlane(this.stepDatas[0].view, point, p);
+                return p.sub(point).isParallelTo(plane.normal) === false;
+            },
+        };
+    };
+
+    private readonly circlePreview = (point: XYZ | undefined) => {
+        if (!point) return [this.meshPoint(this.stepDatas[0].point!)];
+
+        const start = this.stepDatas[0].point!;
+        const plane = this.findPlane(this.stepDatas[0].view, start, point);
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshLine(start, point),
+            this.meshCreatedShape("circle", plane.normal, start, plane.projectDistance(start, point)),
+        ];
+    };
+
+    private readonly getHeightStepData = (): LengthAtAxisSnapData => {
+        return {
+            point: this.stepDatas[0].point!,
+            direction: this.stepDatas[1].plane!.normal,
+            preview: this.previewCone,
+        };
+    };
+
+    private readonly previewCone = (end: XYZ | undefined) => {
+        if (!end) {
+            return this.circlePreview(this.stepDatas[1].point);
+        }
+        const center = this.stepDatas[0].point!;
+        const p1Visual = this.meshPoint(center);
+        const plane = this.stepDatas[1].plane!;
+        const radius = plane.projectDistance(center, this.stepDatas[1].point!);
+        const up = center.add(plane.normal.multiply(this.getHeight(plane, end)));
+        return [
+            p1Visual,
+            this.meshCreatedShape("circle", plane.normal, center, radius),
+            this.meshLine(center.add(plane.xvec.multiply(radius)), up),
+            this.meshLine(center.add(plane.xvec.multiply(-radius)), up),
+            this.meshLine(center.add(plane.yvec.multiply(radius)), up),
+            this.meshLine(center.add(plane.yvec.multiply(-radius)), up),
+        ];
+    };
+
+    protected override meshLine(start: XYZ, end: XYZ) {
+        return EdgeMeshData.from(start, end, VisualConfig.defaultEdgeColor, LineType.Solid);
+    }
+
+    protected override geometryNode(): GeometryNode {
+        const plane = this.stepDatas[1].plane!;
+        const radius = plane.projectDistance(this.stepDatas[0].point!, this.stepDatas[1].point!);
+        const height = this.getHeight(plane, this.stepDatas[2].point!);
+        return new ConeNode(
+            this.document,
+            height < 0 ? plane.normal.reverse() : plane.normal,
+            this.stepDatas[0].point!,
+            radius,
+            Math.abs(height),
+        );
+    }
+
+    private getHeight(plane: Plane, point: XYZ): number {
+        return point.sub(this.stepDatas[0].point!).dot(plane.normal);
+    }
+}

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

@@ -0,0 +1,159 @@
+// 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,
+    command,
+    EditableShapeNode,
+    type GeometryNode,
+    type IDocument,
+    type IEdge,
+    type IFace,
+    type INode,
+    type IShape,
+    type IShapeFilter,
+    type IShell,
+    PubSub,
+    Result,
+    type ShapeNode,
+    ShapeNodeFilter,
+    ShapeType,
+    Transaction,
+} from "chili-core";
+import { FaceNode } from "../../bodys/face";
+import { WireNode } from "../../bodys/wire";
+import { SelectNodeStep } from "../../step";
+
+abstract class ConvertCommand extends CancelableCommand {
+    async executeAsync(): Promise<void> {
+        const models = await this.getOrPickModels(this.document);
+        if (!models) {
+            PubSub.default.pub("showToast", "toast.select.noSelected");
+            return;
+        }
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            const node = this.create(this.document, models);
+            if (!node.isOk) {
+                PubSub.default.pub("showToast", "toast.converter.error");
+            } else {
+                this.document.modelManager.rootNode.add(node.value);
+                this.document.visual.update();
+                PubSub.default.pub("showToast", "toast.success");
+            }
+
+            models.forEach((x) => x.parent?.remove(x));
+        });
+    }
+
+    protected abstract create(document: IDocument, models: INode[]): Result<GeometryNode>;
+    protected shapeFilter(): IShapeFilter {
+        return {
+            allow: (shape: IShape) =>
+                shape.shapeType === ShapeType.Edge || shape.shapeType === ShapeType.Wire,
+        };
+    }
+
+    async getOrPickModels(document: IDocument) {
+        const filter = this.shapeFilter();
+        const models = this._getSelectedModels(document, filter);
+        document.selection.clearSelection();
+        if (models.length > 0) return models;
+
+        const step = new SelectNodeStep("prompt.select.models", {
+            filter: new ShapeNodeFilter(filter),
+            multiple: true,
+        });
+        this.controller = new AsyncController();
+        const data = await step.execute(document, this.controller);
+        document.selection.clearSelection();
+        return data?.nodes;
+    }
+
+    private _getSelectedModels(document: IDocument, filter?: IShapeFilter) {
+        return document.selection
+            .getSelectedNodes()
+            .map((x) => x as ShapeNode)
+            .filter((x) => {
+                if (x === undefined) return false;
+                const shape = x.shape.value;
+                if (shape === undefined) return false;
+                if (filter !== undefined && !filter.allow(shape)) return false;
+                return true;
+            });
+    }
+}
+
+@command({
+    key: "convert.toWire",
+    icon: "icon-toPoly",
+})
+export class ConvertToWire extends ConvertCommand {
+    protected override create(document: IDocument, models: ShapeNode[]): Result<GeometryNode> {
+        const edges = models.map((x) => x.shape.value.transformedMul(x.worldTransform())) as IEdge[];
+        const wireBody = new WireNode(document, edges);
+        const shape = wireBody.generateShape();
+        if (!shape.isOk) return Result.err(shape.error);
+
+        return Result.ok(wireBody);
+    }
+}
+
+@command({
+    key: "convert.toFace",
+    icon: "icon-toFace",
+})
+export class ConvertToFace extends ConvertCommand {
+    protected override create(document: IDocument, models: ShapeNode[]): Result<GeometryNode> {
+        const edges = models.map((x) => x.shape.value.transformedMul(x.worldTransform())) as IEdge[];
+        const wireBody = new FaceNode(document, edges);
+        const shape = wireBody.generateShape();
+        if (!shape.isOk) return Result.err(shape.error);
+
+        return Result.ok(wireBody);
+    }
+}
+
+@command({
+    key: "convert.toShell",
+    icon: "icon-toShell",
+})
+export class ConvertToShell extends ConvertCommand {
+    protected override shapeFilter(): IShapeFilter {
+        return {
+            allow: (shape: IShape) => shape.shapeType === ShapeType.Face,
+        };
+    }
+
+    protected override create(document: IDocument, models: ShapeNode[]): Result<GeometryNode> {
+        const faces = models.map((x) => x.shape.value.transformedMul(x.worldTransform())) as IFace[];
+        const shape = this.application.shapeFactory.shell(faces);
+        faces.forEach((x) => x.dispose());
+        if (!shape.isOk) return Result.err(shape.error);
+
+        const shell = new EditableShapeNode(document, "shell", shape);
+        return Result.ok(shell);
+    }
+}
+
+@command({
+    key: "convert.toSolid",
+    icon: "icon-toSolid",
+})
+export class ConvertToSolid extends ConvertCommand {
+    protected override shapeFilter(): IShapeFilter {
+        return {
+            allow: (shape: IShape) => shape.shapeType === ShapeType.Shell,
+        };
+    }
+
+    protected override create(document: IDocument, models: ShapeNode[]): Result<GeometryNode> {
+        const faces = models.map((x) => x.shape.value.transformedMul(x.worldTransform())) as IShell[];
+        const shape = this.application.shapeFactory.solid(faces);
+        faces.forEach((x) => x.dispose());
+        if (!shape.isOk) return Result.err(shape.error);
+
+        const solid = new EditableShapeNode(document, "solid", shape);
+        return Result.ok(solid);
+    }
+}

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

@@ -0,0 +1,37 @@
+// 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, PubSub, ShapeType, Transaction } from "chili-core";
+import { SelectShapeStep } from "../../step/selectStep";
+import { MultistepCommand } from "../multistepCommand";
+
+@command({
+    key: "create.copyShape",
+    icon: "icon-subShape",
+})
+export class CopySubShapeCommand extends MultistepCommand {
+    protected override executeMainTask() {
+        Transaction.execute(this.document, `excute ${Object.getPrototypeOf(this).data.name}`, () => {
+            this.stepDatas[0].shapes.forEach((x) => {
+                const subShape = x.shape.clone();
+                const model = new EditableShapeNode(
+                    this.document,
+                    ShapeType.stringValue(subShape.shapeType),
+                    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() {
+        return [
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Face, "prompt.select.shape", { multiple: true }),
+        ];
+    }
+}

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

@@ -0,0 +1,61 @@
+// 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,
+    type IEdge,
+    type IFace,
+    type IWire,
+    Property,
+    ShapeType,
+    XYZ,
+} from "chili-core";
+import { type IStep, SelectShapeStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "convert.curveProjection",
+    icon: "icon-curveProject",
+})
+export class CurveProjectionCommand extends CreateCommand {
+    @Property.define("common.dir")
+    get dir() {
+        return this.getPrivateValue("dir", "0,0,-1");
+    }
+
+    set dir(value: string) {
+        const nums = this.dir
+            .split(",")
+            .map(Number)
+            .filter((n) => !isNaN(n));
+        if (nums.length !== 3) {
+            alert(I18n.translate("error.input.threeNumberCanBeInput"));
+
+            return;
+        }
+        this.setProperty("dir", value);
+    }
+
+    protected override geometryNode() {
+        const shape = this.transformdFirstShape(this.stepDatas[0]) as IEdge | IWire;
+        const face = this.transformdFirstShape(this.stepDatas[1]) as IFace;
+        const [x, y, z] = this.dir.split(",").map(Number);
+        const dir = new XYZ(x, y, z).normalize() as XYZ;
+
+        const curveProjection = this.application.shapeFactory.curveProjection(shape, face, dir);
+        return new EditableShapeNode(
+            this.document,
+            I18n.translate("command.convert.curveProjection"),
+            curveProjection.value,
+        );
+    }
+
+    protected override getSteps(): IStep[] {
+        return [
+            new SelectShapeStep(ShapeType.Edge | ShapeType.Wire, "prompt.select.shape"),
+            new SelectShapeStep(ShapeType.Face, "prompt.select.faces", { keepSelection: true }),
+        ];
+    }
+}

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

@@ -0,0 +1,96 @@
+// 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 { CylinderNode } from "../../bodys";
+import type { LengthAtAxisSnapData, SnapLengthAtPlaneData } from "../../snap";
+import { type IStep, LengthAtAxisStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateCommand } from "../createCommand";
+
+@command({
+    key: "create.cylinder",
+    icon: "icon-cylinder",
+})
+export class Cylinder extends CreateCommand {
+    protected override getSteps(): IStep[] {
+        const centerStep = new PointStep("prompt.pickCircleCenter");
+        const radiusStep = new LengthAtPlaneStep("prompt.pickRadius", this.getRadiusData);
+        const third = new LengthAtAxisStep("prompt.pickNextPoint", this.getHeightStepData);
+        return [centerStep, radiusStep, third];
+    }
+
+    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;
+            },
+        };
+    };
+
+    private readonly circlePreview = (point: XYZ | undefined) => {
+        if (!point) return [this.meshPoint(this.stepDatas[0].point!)];
+
+        const start = this.stepDatas[0].point!;
+        const plane = this.findPlane(this.stepDatas[0].view, start, point);
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshLine(start, point),
+            this.meshCreatedShape("circle", plane.normal, start, plane.projectDistance(start, point)),
+        ];
+    };
+
+    private readonly getHeightStepData = (): LengthAtAxisSnapData => {
+        return {
+            point: this.stepDatas[0].point!,
+            direction: this.stepDatas[1].plane!.normal,
+            preview: this.previewCylinder,
+            validator: (p: XYZ) => {
+                return Math.abs(this.getHeight(this.stepDatas[1].plane!, p)) > 0.001;
+            },
+        };
+    };
+
+    private readonly previewCylinder = (end: XYZ | undefined) => {
+        if (!end) {
+            return this.circlePreview(this.stepDatas[1].point);
+        }
+
+        const plane = this.stepDatas[1].plane!;
+        const radius = plane.projectDistance(this.stepDatas[0].point!, this.stepDatas[1].point!);
+        const height = this.getHeight(plane, end);
+
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshCreatedShape(
+                "cylinder",
+                height < 0 ? plane.normal.reverse() : plane.normal,
+                this.stepDatas[0].point!,
+                radius,
+                Math.abs(height),
+            ),
+        ];
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const plane = this.stepDatas[1].plane!;
+        const radius = plane.projectDistance(this.stepDatas[0].point!, this.stepDatas[1].point!);
+        const dz = this.getHeight(plane, this.stepDatas[2].point!);
+        return new CylinderNode(
+            this.document,
+            dz < 0 ? plane.normal.reverse() : plane.normal,
+            this.stepDatas[0].point!,
+            radius,
+            Math.abs(dz),
+        );
+    }
+
+    private getHeight(plane: Plane, point: XYZ): number {
+        return point.sub(this.stepDatas[0].point!).dot(plane.normal);
+    }
+}

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

@@ -0,0 +1,95 @@
+// 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 { EllipseNode } from "../../bodys/ellipse";
+import type { LengthAtAxisSnapData, SnapLengthAtPlaneData } from "../../snap";
+import { type IStep, LengthAtAxisStep, LengthAtPlaneStep, PointStep } from "../../step";
+import { CreateFaceableCommand } from "../createCommand";
+
+@command({
+    key: "create.ellipse",
+    icon: "icon-ellipse",
+})
+export class Ellipse extends CreateFaceableCommand {
+    getSteps(): IStep[] {
+        const centerStep = new PointStep("prompt.pickCircleCenter");
+        const radiusStepX = new LengthAtPlaneStep("prompt.pickRadius", this.getRadius1Data);
+        const radiusStepY = new LengthAtAxisStep("prompt.pickRadius", this.getRadius2Data);
+        return [centerStep, radiusStepX, radiusStepY];
+    }
+
+    private readonly getRadius1Data = (): SnapLengthAtPlaneData => {
+        const point = this.stepDatas[0].point!;
+        return {
+            point: () => point,
+            preview: this.previewCircle,
+            plane: (tmp: XYZ | undefined) => this.findPlane(this.stepDatas[0].view, point, tmp),
+            validator: this.validatePoint,
+        };
+    };
+
+    private readonly validatePoint = (point: XYZ) => {
+        const center = this.stepDatas[0].point!;
+        if (point.distanceTo(center) < Precision.Distance) return false;
+        const plane = this.findPlane(this.stepDatas[0].view, center, point);
+        return point.sub(center).isParallelTo(plane.normal) === false;
+    };
+
+    protected previewCircle = (end: XYZ | undefined) => {
+        if (end === undefined) return [this.meshPoint(this.stepDatas[0].point!)];
+
+        const plane = this.findPlane(this.stepDatas[0].view, this.stepDatas[0].point!, end);
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(end),
+            this.meshCreatedShape(
+                "circle",
+                plane.normal,
+                this.stepDatas[0].point!,
+                end.distanceTo(this.stepDatas[0].point!),
+            ),
+        ];
+    };
+
+    private readonly getRadius2Data = (): LengthAtAxisSnapData => {
+        const point = this.stepDatas[0].point!;
+        const plane = this.stepDatas[1].plane!;
+        const direction = plane.normal.cross(this.stepDatas[1].point!.sub(point)).normalize()!;
+        return {
+            point: point,
+            preview: this.ellipsePreview,
+            direction,
+            validator: this.validatePoint,
+        };
+    };
+
+    protected override geometryNode(): GeometryNode {
+        const [p0, p1, p2] = [this.stepDatas[0].point!, this.stepDatas[1].point!, this.stepDatas[2].point!];
+        const plane = this.stepDatas[1].plane!;
+        const d1 = plane.projectDistance(p0, p1);
+        const d2 = plane.projectDistance(p0, p2);
+        const body = new EllipseNode(this.document, plane.normal, p0, p1.sub(p0), d1, d2 > d1 ? d1 : d2);
+        return body;
+    }
+
+    private readonly ellipsePreview = (point: XYZ | undefined) => {
+        if (!point) return this.previewCircle(this.stepDatas[1].point);
+
+        return [
+            this.meshPoint(this.stepDatas[0].point!),
+            this.meshPoint(this.stepDatas[1].point!),
+            this.createEllipse(point),
+        ];
+    };
+
+    private createEllipse(p2: XYZ) {
+        const p0 = this.stepDatas[0].point!;
+        const p1 = this.stepDatas[1].point!;
+        const plane = this.stepDatas[1].plane!;
+
+        const d1 = plane.projectDistance(p0, p1);
+        const d2 = plane.projectDistance(p0, p2);
+        return this.meshCreatedShape("ellipse", plane.normal, p0, p1.sub(p0), d1, d2 > d1 ? d1 : d2);
+    }
+}