chili3d 0.6.1

package/packages/chili/src/snap/handlers/angleSnapEventHandler.ts

@@ -0,0 +1,60 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type AsyncController,
+    Config,
+    type IDocument,
+    type IView,
+    Plane,
+    PlaneAngle,
+    type XYZ,
+} from "chili-core";
+import type { SnapResult } from "../snap";
+import { ObjectSnap, PlaneSnap } from "../snaps";
+import { TrackingSnap } from "../tracking";
+import type { PointSnapData } from "./pointSnapEventHandler";
+import { SnapEventHandler } from "./snapEventHandler";
+
+export class AngleSnapEventHandler extends SnapEventHandler<PointSnapData> {
+    private readonly planeAngle: PlaneAngle;
+    private readonly plane: Plane;
+
+    constructor(
+        document: IDocument,
+        controller: AsyncController,
+        private readonly center: () => XYZ,
+        p1: XYZ,
+        snapPointData: PointSnapData,
+    ) {
+        if (!snapPointData.plane) throw new Error("AngleSnapEventHandler: no plane");
+
+        const objectSnap = new ObjectSnap(Config.instance.snapType, snapPointData.refPoint);
+        const workplaneSnap = new PlaneSnap(snapPointData.plane, center);
+        const trackingSnap = new TrackingSnap(center, false);
+        super(document, controller, [objectSnap, trackingSnap, workplaneSnap], snapPointData);
+
+        const xvec = p1.sub(center()).normalize()!;
+        this.plane = new Plane(center(), snapPointData.plane().normal, xvec);
+        this.planeAngle = new PlaneAngle(this.plane);
+        snapPointData.prompt ??= this.formatAnglePrompt;
+    }
+
+    private readonly formatAnglePrompt = (snaped?: SnapResult) => {
+        if (!snaped?.point) return "";
+        this.planeAngle.movePoint(snaped.point);
+        return `${this.planeAngle.angle.toFixed(2)} °`;
+    };
+
+    protected override inputError(text: string) {
+        const angle = Number.parseFloat(text);
+        return isNaN(angle) ? "error.input.invalidNumber" : undefined;
+    }
+
+    protected override getPointFromInput(view: IView, text: string): SnapResult {
+        const angle = (Number.parseFloat(text) * Math.PI) / 180;
+        const vec = this.plane.xvec.rotate(this.plane.normal, angle)!;
+        const point = this.center().add(vec);
+        return { point, view, shapes: [], plane: this.plane };
+    }
+}

package/packages/chili/src/snap/handlers/index.ts

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

package/packages/chili/src/snap/handlers/lengthSnapEventHandler.ts

@@ -0,0 +1,117 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type AsyncController,
+    Config,
+    type I18nKeys,
+    type IDocument,
+    type IView,
+    type Plane,
+    Precision,
+    type XYZ,
+} from "chili-core";
+import type { SnapData, SnapResult } from "../snap";
+import { AxisSnap, ObjectSnap, PlaneSnap } from "../snaps";
+import { TrackingSnap } from "../tracking";
+import { SnapEventHandler } from "./snapEventHandler";
+
+export interface LengthAtAxisSnapData extends SnapData {
+    point: XYZ;
+    direction: XYZ;
+}
+
+export interface SnapLengthAtPlaneData extends SnapData {
+    point: () => XYZ;
+    plane: (point: XYZ | undefined) => Plane;
+}
+
+export class SnapLengthAtAxisHandler extends SnapEventHandler<LengthAtAxisSnapData> {
+    constructor(document: IDocument, controller: AsyncController, lengthData: LengthAtAxisSnapData) {
+        const objectSnap = new ObjectSnap(Config.instance.snapType, () => lengthData.point);
+        const axisSnap = new AxisSnap(lengthData.point, lengthData.direction);
+        super(document, controller, [objectSnap, axisSnap], lengthData);
+    }
+
+    protected getPointFromInput(view: IView, text: string): SnapResult {
+        const dist = this.calculateDistance(Number(text));
+        const point = this.calculatePoint(dist);
+        return { view, point, distance: dist, shapes: [] };
+    }
+
+    private calculateDistance(inputValue: number): number {
+        return this.shouldReverse() ? -inputValue : inputValue;
+    }
+
+    private calculatePoint(distance: number): XYZ {
+        return this.data.point.add(this.data.direction.multiply(distance));
+    }
+
+    private shouldReverse() {
+        return (
+            this._snaped?.point &&
+            this._snaped.point.sub(this.data.point).dot(this.data.direction) < -Precision.Distance
+        );
+    }
+
+    protected inputError(text: string): I18nKeys | undefined {
+        return Number.isNaN(Number(text)) ? "error.input.invalidNumber" : undefined;
+    }
+}
+
+export class SnapLengthAtPlaneHandler extends SnapEventHandler<SnapLengthAtPlaneData> {
+    private workplane: Plane | undefined;
+
+    constructor(
+        document: IDocument,
+        controller: AsyncController,
+        readonly lengthData: SnapLengthAtPlaneData,
+    ) {
+        const objectSnap = new ObjectSnap(Config.instance.snapType, lengthData.point);
+        const trackingSnap = new TrackingSnap(lengthData.point, false);
+        const planeSnap = new PlaneSnap(lengthData.plane, lengthData.point);
+        super(document, controller, [objectSnap, trackingSnap, planeSnap], lengthData);
+    }
+
+    protected override setSnaped(view: IView, event: PointerEvent): void {
+        super.setSnaped(view, event);
+        this.updateWorkplane();
+    }
+
+    private updateWorkplane() {
+        if (this._snaped) {
+            this.workplane = this.lengthData.plane(this._snaped.point);
+            this._snaped.plane = this.workplane;
+        }
+    }
+
+    protected getPointFromInput(view: IView, text: string): SnapResult {
+        const plane = this.workplane ?? view.workplane;
+        const point = this.calculatePoint(text, plane);
+        return { point, view, shapes: [], plane };
+    }
+
+    private calculatePoint(text: string, plane: Plane): XYZ {
+        const numbers = text.split(",").map(Number);
+        return numbers.length === 1
+            ? this.calculatePointFromDistance(numbers[0])
+            : this.calculatePointFromCoordinates(numbers, plane);
+    }
+
+    private calculatePointFromDistance(distance: number): XYZ {
+        const vector = this._snaped?.point!.sub(this.data.point()).normalize();
+        return this.data.point().add(vector!.multiply(distance));
+    }
+
+    private calculatePointFromCoordinates(coords: number[], plane: Plane): XYZ {
+        return this.data.point().add(plane.xvec.multiply(coords[0])).add(plane.yvec.multiply(coords[1]));
+    }
+
+    protected inputError(text: string): I18nKeys | undefined {
+        const numbers = text.split(",").map(Number);
+        if (numbers.some(Number.isNaN) || (numbers.length !== 1 && numbers.length !== 2)) {
+            return "error.input.invalidNumber";
+        }
+        return undefined;
+    }
+}

package/packages/chili/src/snap/handlers/pointSnapEventHandler.ts

@@ -0,0 +1,176 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type AsyncController,
+    Config,
+    type I18nKeys,
+    type ICurve,
+    type IDocument,
+    type IView,
+    type Line,
+    type Plane,
+    type ShapeType,
+    XYZ,
+} from "chili-core";
+import { Dimension } from "../dimension";
+import type { ISnap, SnapData, SnapResult } from "../snap";
+import { AxisSnap, ObjectSnap, PlaneSnap, PointOnCurveSnap, WorkplaneSnap } from "../snaps";
+import { TrackingSnap } from "../tracking";
+import { SnapEventHandler } from "./snapEventHandler";
+
+export interface PointSnapData extends SnapData {
+    dimension?: Dimension;
+    refPoint?: () => XYZ;
+    plane?: () => Plane;
+}
+
+export interface SnapPointOnCurveData extends PointSnapData {
+    curve: ICurve;
+}
+
+export interface SnapPointOnAxisData extends PointSnapData {
+    ray: Line;
+}
+
+export class PointSnapEventHandler extends SnapEventHandler<PointSnapData> {
+    constructor(document: IDocument, controller: AsyncController, pointData: PointSnapData) {
+        super(document, controller, [], pointData);
+        this.snaps.push(...this.getInitSnaps(pointData));
+    }
+
+    protected getInitSnaps(pointData: PointSnapData): ISnap[] {
+        const objectSnap = new ObjectSnap(Config.instance.snapType, pointData.refPoint);
+        const workplaneSnap = pointData.plane
+            ? new PlaneSnap(pointData.plane, pointData.refPoint)
+            : new WorkplaneSnap(pointData.refPoint);
+        const trackingSnap = new TrackingSnap(pointData.refPoint, true);
+        return [objectSnap, trackingSnap, workplaneSnap];
+    }
+
+    protected getPointFromInput(view: IView, text: string): SnapResult {
+        const [dims, isAbsolute] = this.parseInputDimensions(text);
+        const refPoint = this.getRefPoint() ?? XYZ.zero;
+        const result = { point: refPoint, view, shapes: [] };
+
+        if (isAbsolute) {
+            result.point = new XYZ(dims[0], dims[1], dims[2]);
+        } else if (dims.length === 1 && this._snaped?.point) {
+            result.point = this.calculatePointFromDistance(refPoint, dims[0]);
+        } else if (dims.length > 1) {
+            result.point = this.calculatePointFromCoordinates(refPoint, dims);
+        }
+
+        return result;
+    }
+
+    private parseInputDimensions(text: string): [number[], boolean] {
+        const isAbsolute = text.startsWith("#");
+        if (isAbsolute) {
+            text = text.slice(1);
+        }
+        return [text.split(",").map(Number), isAbsolute];
+    }
+
+    private calculatePointFromDistance(refPoint: XYZ, distance: number): XYZ {
+        const vector = this._snaped!.point!.sub(refPoint).normalize()!;
+        return refPoint.add(vector.multiply(distance));
+    }
+
+    private calculatePointFromCoordinates(refPoint: XYZ, dims: number[]): XYZ {
+        const plane = this.data.plane?.() ?? this.snaped!.view.workplane;
+        let point = refPoint.add(plane.xvec.multiply(dims[0])).add(plane.yvec.multiply(dims[1]));
+        if (dims.length === 3) {
+            point = point.add(plane.normal.multiply(dims[2]));
+        }
+        return point;
+    }
+
+    protected inputError(text: string): I18nKeys | undefined {
+        const [dims, isAbsolute] = this.parseInputDimensions(text);
+        const dimension = Dimension.from(dims.length);
+
+        if (isAbsolute && dims.length !== 3) return "error.input.threeNumberCanBeInput";
+        if (!this.isValidDimension(dimension)) return "error.input.unsupportedInputs";
+        if (this.hasInvalidNumbers(dims)) return "error.input.invalidNumber";
+        if (this.requiresThreeNumbers(dims)) return "error.input.threeNumberCanBeInput";
+        if (this.isInvalidSingleNumber(dims)) return "error.input.cannotInputANumber";
+
+        return undefined;
+    }
+
+    private isValidDimension(dimension: Dimension): boolean {
+        return Dimension.contains(this.data.dimension!, dimension);
+    }
+
+    private hasInvalidNumbers(dims: number[]): boolean {
+        return dims.some(Number.isNaN);
+    }
+
+    private requiresThreeNumbers(dims: number[]): boolean {
+        const refPoint = this.getRefPoint();
+        return refPoint === undefined && dims.length !== 3;
+    }
+
+    private isInvalidSingleNumber(dims: number[]): boolean {
+        const refPoint = this.getRefPoint();
+        return dims.length === 1 && refPoint! && (!this._snaped || this._snaped.point!.isEqualTo(refPoint));
+    }
+
+    private getRefPoint(): XYZ | undefined {
+        return this.data.refPoint?.() ?? this._snaped?.refPoint;
+    }
+}
+
+export class SnapPointOnCurveEventHandler extends SnapEventHandler<SnapPointOnCurveData> {
+    constructor(document: IDocument, controller: AsyncController, pointData: SnapPointOnCurveData) {
+        const objectSnap = new ObjectSnap(Config.instance.snapType);
+        const snap = new PointOnCurveSnap(pointData);
+        const workplaneSnap = new WorkplaneSnap();
+        super(document, controller, [objectSnap, snap, workplaneSnap], pointData);
+    }
+
+    protected override getPointFromInput(view: IView, text: string): SnapResult {
+        const length = this.data.curve.length();
+        const parameter = Number(text) / length;
+        return { point: this.data.curve.value(parameter), view, shapes: [] };
+    }
+
+    protected override inputError(text: string) {
+        return Number.isNaN(Number(text)) ? "error.input.invalidNumber" : undefined;
+    }
+}
+
+export class SnapPointOnAxisEventHandler extends SnapEventHandler<SnapPointOnAxisData> {
+    constructor(document: IDocument, controller: AsyncController, pointData: SnapPointOnAxisData) {
+        const objectSnap = new ObjectSnap(Config.instance.snapType);
+        const snap = new AxisSnap(pointData.ray.point, pointData.ray.direction);
+        super(document, controller, [objectSnap, snap], pointData);
+    }
+
+    protected override getPointFromInput(view: IView, text: string): SnapResult {
+        const parameter = Number(text);
+        const point = this.data.ray.point.add(this.data.ray.direction.multiply(parameter));
+        return { point, view, shapes: [] };
+    }
+
+    protected override inputError(text: string) {
+        return Number.isNaN(Number(text)) ? "error.input.invalidNumber" : undefined;
+    }
+}
+
+export class SnapPointPlaneEventHandler extends PointSnapEventHandler {
+    protected override getInitSnaps(pointData: PointSnapData): ISnap[] {
+        if (!pointData.plane) throw new Error("plane is required");
+
+        return [new ObjectSnap(Config.instance.snapType), new PlaneSnap(pointData.plane)];
+    }
+
+    protected override findSnapPoint(shapeType: ShapeType, view: IView, event: PointerEvent): void {
+        super.findSnapPoint(shapeType, view, event);
+
+        if (this._snaped?.point) {
+            this._snaped.point = this.data.plane!().project(this._snaped.point);
+        }
+    }
+}

package/packages/chili/src/snap/handlers/snapEventHandler.ts

@@ -0,0 +1,288 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type AsyncController,
+    Config,
+    type I18nKeys,
+    type IDocument,
+    type IEventHandler,
+    IView,
+    MessageType,
+    PubSub,
+    Result,
+    ShapeType,
+    VertexMeshData,
+    VisualConfig,
+    type XYZ,
+} from "chili-core";
+import type { ISnap, MouseAndDetected, SnapData, SnapResult } from "../snap";
+
+enum SnapState {
+    Idle,
+    Snapping,
+    Inputing,
+    Cancelled,
+    Completed,
+}
+
+export abstract class SnapEventHandler<D extends SnapData = SnapData> implements IEventHandler {
+    private _tempPoint?: number;
+    private _tempShapes?: number[];
+    protected showTempPoint: boolean = true;
+    protected _snaped?: SnapResult;
+    private _state: SnapState = SnapState.Idle;
+
+    facePreviewOpacity: number = 1;
+    isEnabled: boolean = true;
+
+    constructor(
+        readonly document: IDocument,
+        readonly controller: AsyncController,
+        readonly snaps: ISnap[],
+        readonly data: D,
+    ) {
+        this.showTempShape(undefined);
+        controller.onCancelled(() => this.handleCancel());
+        controller.onCompleted(() => this.handleSuccess());
+    }
+
+    get snaped() {
+        return this._snaped;
+    }
+    get state() {
+        return this._state;
+    }
+
+    dispose() {
+        this._snaped = undefined;
+        this._state = SnapState.Completed;
+    }
+
+    private handleSuccess() {
+        if (this._state === SnapState.Completed) return;
+
+        this._state = SnapState.Completed;
+        this.controller.success();
+        this.cleanupResources();
+    }
+
+    private handleCancel() {
+        if (this._state === SnapState.Cancelled) return;
+
+        this._state = SnapState.Cancelled;
+        this.controller.cancel();
+        this.cleanupResources();
+    }
+
+    private cleanupResources() {
+        this.clearSnapPrompt();
+        this.clearInput();
+        this.removeTempVisuals();
+        this.snaps.forEach((snap) => snap.clear());
+    }
+
+    private clearInput() {
+        PubSub.default.pub("clearInput");
+    }
+
+    pointerMove(view: IView, event: PointerEvent): void {
+        this._state = SnapState.Snapping;
+        this.removeTempVisuals();
+        this.updateSnapPoint(view, event);
+        this.updateVisualFeedback(view);
+    }
+
+    private updateSnapPoint(view: IView, event: PointerEvent) {
+        this.setSnaped(view, event);
+        if (this._snaped) {
+            this.showSnapPrompt(this._snaped);
+        } else {
+            this.clearSnapPrompt();
+        }
+    }
+
+    private updateVisualFeedback(view: IView) {
+        this.showTempShape(this._snaped?.point);
+        view.document.visual.update();
+    }
+
+    protected setSnaped(view: IView, event: PointerEvent) {
+        this.findSnapPoint(ShapeType.Edge, view, event);
+
+        this.snaps.forEach((snap) => snap.handleSnaped?.(view.document.visual.document, this._snaped));
+    }
+
+    private findNearestFeaturePoint(view: IView, event: PointerEvent) {
+        let minDist = Number.MAX_VALUE;
+        let nearest;
+
+        for (const point of this.data.featurePoints || []) {
+            if (point.when && !point.when()) continue;
+
+            const dist = IView.screenDistance(view, event.offsetX, event.offsetY, point.point);
+            if (dist < minDist) {
+                minDist = dist;
+                nearest = point;
+            }
+        }
+
+        return minDist < Config.instance.SnapDistance ? nearest : undefined;
+    }
+
+    protected findSnapPoint(shapeType: ShapeType, view: IView, event: PointerEvent) {
+        const featurePoint = this.findNearestFeaturePoint(view, event);
+        if (featurePoint) {
+            this._snaped = {
+                view,
+                point: featurePoint.point,
+                info: featurePoint.prompt,
+                shapes: [],
+            };
+        } else {
+            const detected = this.detectShapes(shapeType, view, event);
+            for (const snap of this.snaps) {
+                const snaped = snap.snap(detected);
+                if (snaped && this.validateSnapPoint(snaped)) {
+                    this._snaped = snaped;
+                    return;
+                }
+            }
+        }
+    }
+
+    private validateSnapPoint(snaped: SnapResult) {
+        return !this.data.validator || this.data.validator(snaped.point!);
+    }
+
+    private detectShapes(shapeType: ShapeType, view: IView, event: MouseEvent): MouseAndDetected {
+        const shapes = view.detectShapes(shapeType, event.offsetX, event.offsetY, this.data.filter);
+        return { shapes, view, mx: event.offsetX, my: event.offsetY };
+    }
+
+    protected clearSnapPrompt() {
+        PubSub.default.pub("clearFloatTip");
+    }
+
+    protected showSnapPrompt(snaped: SnapResult) {
+        const prompt = this.formatSnapPrompt(snaped);
+        if (!prompt) {
+            this.clearSnapPrompt();
+            return;
+        }
+        PubSub.default.pub("showFloatTip", prompt);
+    }
+
+    protected formatSnapPrompt(
+        snaped: SnapResult,
+    ): HTMLElement | { level: MessageType; msg: string } | undefined {
+        let prompt = this.data.prompt?.(snaped);
+        if (!prompt) {
+            const distance = snaped.distance ?? snaped.refPoint?.distanceTo(snaped.point!);
+            if (distance) {
+                prompt = this.formatSnapDistance(distance);
+            }
+        }
+
+        if (!prompt && !snaped.info) {
+            return undefined;
+        }
+
+        return {
+            level: MessageType.info,
+            msg: [snaped.info, prompt].filter((x) => x !== undefined).join(" -> "),
+        };
+    }
+
+    protected formatSnapDistance(num: number) {
+        return num.toFixed(2);
+    }
+
+    private removeTempVisuals() {
+        this.removeTempShapes();
+        this.snaps.forEach((snap) => snap.removeDynamicObject());
+    }
+
+    private showTempShape(point: XYZ | undefined) {
+        if (point && this.showTempPoint) {
+            const data = VertexMeshData.from(
+                point,
+                VisualConfig.temporaryVertexSize,
+                VisualConfig.temporaryVertexColor,
+            );
+            this._tempPoint = this.document.visual.context.displayMesh([data]);
+        }
+
+        this._tempShapes = this.data
+            .preview?.(point)
+            ?.map((shape) => this.document.visual.context.displayMesh([shape], this.facePreviewOpacity));
+    }
+
+    private removeTempShapes() {
+        if (this._tempPoint) {
+            this.document.visual.context.removeMesh(this._tempPoint);
+            this._tempPoint = undefined;
+        }
+        this._tempShapes?.forEach((id) => {
+            this.document.visual.context.removeMesh(id);
+        });
+        this.document.visual.update();
+        this._tempShapes = undefined;
+    }
+
+    pointerDown(view: IView, event: PointerEvent): void {
+        if (event.pointerType === "mouse" && event.button === 0) {
+            if (this._snaped) {
+                this.handleSuccess();
+            } else {
+                PubSub.default.pub("showToast", "toast.snap.notFoundValidPoint");
+            }
+        }
+    }
+
+    pointerUp(view: IView, event: PointerEvent): void {
+        if (event.pointerType !== "mouse" && event.isPrimary && this._snaped) {
+            this.handleSuccess();
+        }
+    }
+
+    pointerOut(view: IView, event: PointerEvent) {
+        this._snaped = undefined;
+    }
+
+    mouseWheel(view: IView, event: WheelEvent): void {
+        view.update();
+    }
+
+    keyDown(view: IView, event: KeyboardEvent): void {
+        switch (event.key) {
+            case "Escape":
+                this._snaped = undefined;
+                this.handleCancel();
+                break;
+            case "Enter":
+                this._snaped = undefined;
+                this.handleSuccess();
+                break;
+            default:
+                this.handleNumericInput(view, event);
+        }
+    }
+
+    private handleNumericInput(view: IView, event: KeyboardEvent) {
+        if (!["#", "-", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"].includes(event.key)) return;
+
+        this._state = SnapState.Inputing;
+        PubSub.default.pub("showInput", event.key, (text: string) => {
+            const error = this.inputError(text);
+            if (error) return Result.err(error);
+
+            this._snaped = this.getPointFromInput(view, text);
+            this.handleSuccess();
+            return Result.ok(text);
+        });
+    }
+
+    protected abstract getPointFromInput(view: IView, text: string): SnapResult;
+    protected abstract inputError(text: string): I18nKeys | undefined;
+}

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

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