chili3d 0.6.1

package/packages/chili/src/snap/tracking/objectTracking.ts

@@ -0,0 +1,90 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type IDocument, type IView, VisualConfig } from "chili-core";
+import { ViewUtils } from "chili-vis";
+import type { SnapResult } from "..";
+import { Axis } from "./axis";
+import { TrackingBase } from "./trackingBase";
+
+export interface ObjectTrackingAxis {
+    axes: Axis[];
+    objectName: string | undefined;
+}
+
+interface SnapeInfo {
+    snap: SnapResult;
+    shapeId: number;
+}
+
+export class ObjectTracking extends TrackingBase {
+    private timer?: number;
+    private snapping?: SnapResult;
+    private readonly trackings: Map<IDocument, SnapeInfo[]> = new Map();
+
+    constructor(trackingZ: boolean) {
+        super(trackingZ);
+    }
+
+    override clear(): void {
+        this.clearTimer();
+        super.clear();
+        this.trackings.clear();
+    }
+
+    getTrackingRays(view: IView) {
+        const result: ObjectTrackingAxis[] = [];
+        this.trackings.get(view.document)?.map((x) => {
+            const plane = ViewUtils.ensurePlane(view, view.workplane);
+            const axes = Axis.getAxiesAtPlane(x.snap.point!, plane, this.trackingZ);
+            result.push({ axes, objectName: x.snap.info });
+        });
+        return result;
+    }
+
+    showTrackingAtTimeout(document: IDocument, snap?: SnapResult) {
+        if (snap !== undefined && this.snapping === snap) return;
+        this.snapping = snap;
+        this.clearTimer();
+        if (!snap) return;
+        this.timer = window.setTimeout(() => this.switchTrackingPoint(document, snap), 600);
+    }
+
+    private clearTimer() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+
+    private switchTrackingPoint(document: IDocument, snap: SnapResult) {
+        if (this.isCleared || snap.shapes.length === 0) return;
+        if (!this.trackings.has(document)) {
+            this.trackings.set(document, []);
+        }
+        const currentTrackings = this.trackings.get(document)!;
+        const existingTracking = currentTrackings.find((x) => x.snap.point!.isEqualTo(snap.point!));
+        existingTracking
+            ? this.removeTrackingPoint(document, existingTracking, currentTrackings)
+            : this.addTrackingPoint(snap, document, currentTrackings);
+        document.visual.update();
+    }
+
+    private removeTrackingPoint(document: IDocument, s: SnapeInfo, snaps: SnapeInfo[]) {
+        document.visual.context.removeMesh(s.shapeId);
+        this.trackings.set(
+            document,
+            snaps.filter((x) => x !== s),
+        );
+    }
+
+    private addTrackingPoint(snap: SnapResult, document: IDocument, snaps: SnapeInfo[]) {
+        const pointId = this.displayPoint(
+            document,
+            snap,
+            VisualConfig.trackingVertexSize,
+            VisualConfig.trackingVertexColor,
+        );
+        snaps.push({ shapeId: pointId, snap });
+    }
+}

package/packages/chili/src/snap/tracking/trackingBase.ts

@@ -0,0 +1,40 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type IDocument, VertexMeshData } from "chili-core";
+import type { SnapResult } from "..";
+
+export abstract class TrackingBase {
+    protected readonly tempMeshes: Map<IDocument, number[]> = new Map();
+    protected isCleared: boolean = false;
+
+    constructor(readonly trackingZ: boolean) {}
+
+    clear(): void {
+        this.clearTempMeshes();
+        this.isCleared = true;
+    }
+
+    protected clearTempMeshes(): void {
+        this.tempMeshes.forEach((ids, document) => {
+            ids.forEach((id) => document.visual.context.removeMesh(id));
+        });
+        this.tempMeshes.clear();
+    }
+
+    protected addTempMesh(document: IDocument, meshId: number): void {
+        let ids = this.tempMeshes.get(document);
+        if (!ids) {
+            ids = [];
+            this.tempMeshes.set(document, ids);
+        }
+        ids.push(meshId);
+    }
+
+    protected displayPoint(document: IDocument, point: SnapResult, size: number, color: number): number {
+        const data = VertexMeshData.from(point.point!, size, color);
+        const id = document.visual.context.displayMesh([data]);
+        this.addTempMesh(document, id);
+        return id;
+    }
+}

package/packages/chili/src/snap/tracking/trackingSnap.ts

@@ -0,0 +1,201 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    Config,
+    EdgeMeshData,
+    I18n,
+    type IDocument,
+    type ISubEdgeShape,
+    IView,
+    type Line,
+    LineType,
+    Precision,
+    ShapeType,
+    VisualConfig,
+    XY,
+    type XYZ,
+} from "chili-core";
+import type { ISnap, MouseAndDetected, SnapResult } from "../";
+import type { Axis } from "./axis";
+import { AxisTracking } from "./axisTracking";
+import { ObjectTracking } from "./objectTracking";
+
+export interface TrackingData {
+    axis: Axis;
+    point: XYZ;
+    isObjectTracking: boolean;
+    distance: number;
+    info: string;
+}
+
+export class TrackingSnap implements ISnap {
+    private readonly _axisTracking: AxisTracking;
+    private readonly _objectTracking: ObjectTracking;
+    private readonly _tempLines: Map<IView, number[]> = new Map();
+
+    constructor(
+        readonly referencePoint: (() => XYZ) | undefined,
+        trackingAxisZ: boolean,
+    ) {
+        this._axisTracking = new AxisTracking(trackingAxisZ);
+        this._objectTracking = new ObjectTracking(trackingAxisZ);
+        Config.instance.onPropertyChanged(this.onSnapTypeChanged);
+    }
+
+    readonly handleSnaped = (document: IDocument, snaped?: SnapResult) => {
+        if (Config.instance.enableSnapTracking) {
+            this._objectTracking.showTrackingAtTimeout(document, snaped);
+        }
+    };
+
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        if (!Config.instance.enableSnapTracking) return undefined;
+
+        const trackingDatas = this.detectTracking(data.view, data.mx, data.my);
+        if (trackingDatas.length === 0) return undefined;
+        trackingDatas.sort((x) => x.distance);
+        const snaped = this.shapeIntersectTracking(data, trackingDatas);
+        if (snaped !== undefined) return snaped;
+        if (trackingDatas.length === 1) {
+            return this.getSnapedAndShowTracking(data.view, trackingDatas[0].point, [trackingDatas[0]]);
+        }
+        return (
+            this.trackingIntersectTracking(data.view, trackingDatas) ??
+            this.getSnapedAndShowTracking(data.view, trackingDatas[0].point, [trackingDatas[0]])
+        );
+    }
+
+    private trackingIntersectTracking(view: IView, trackingDatas: TrackingData[]) {
+        const point = trackingDatas[0].axis.intersect(trackingDatas[1].axis);
+        return point
+            ? this.getSnapedAndShowTracking(view, point, [trackingDatas[0], trackingDatas[1]])
+            : undefined;
+    }
+
+    private getSnapedAndShowTracking(view: IView, point: XYZ, trackingDatas: TrackingData[]): SnapResult {
+        const lines: number[] = trackingDatas
+            .map((x) => this.showTempLine(view, x.axis.point, point))
+            .filter((id) => id !== undefined);
+        this._tempLines.set(view, lines);
+
+        let info: string | undefined;
+        let distance: number | undefined;
+        if (trackingDatas.length === 1) {
+            distance = point.distanceTo(trackingDatas[0].axis.point);
+            info = trackingDatas[0].axis.name;
+        } else if (trackingDatas.length === 2) {
+            info = I18n.translate("snap.intersection");
+        }
+        const refPoint = trackingDatas[0].axis.point;
+        return { view, point, info, shapes: [], refPoint, distance };
+    }
+
+    private showTempLine(view: IView, start: XYZ, end: XYZ): number | undefined {
+        const vector = end.sub(start);
+        const normal = vector.normalize();
+        if (!normal) return undefined;
+        const distance = Math.min(vector.length() * 1e10, 1e20);
+        const newEnd = start.add(normal.multiply(distance));
+        const lineDats = EdgeMeshData.from(start, newEnd, VisualConfig.temporaryEdgeColor, LineType.Dash);
+        return view.document.visual.context.displayMesh([lineDats]);
+    }
+
+    private shapeIntersectTracking(
+        data: MouseAndDetected,
+        trackingDatas: TrackingData[],
+    ): SnapResult | undefined {
+        if (data.shapes.length === 0 || data.shapes[0].shape.shapeType !== ShapeType.Edge) return undefined;
+        const point = this.findIntersection(data, trackingDatas);
+        if (!point) return undefined;
+        const id = this.showTempLine(data.view, point.location, point.intersect);
+        if (id === undefined) return undefined;
+        this._tempLines.set(data.view, [id]);
+        return {
+            view: data.view,
+            point: point.intersect,
+            info: I18n.translate("snap.intersection"),
+            shapes: [data.shapes[0]],
+        };
+    }
+
+    private findIntersection(data: MouseAndDetected, trackingDatas: TrackingData[]) {
+        const edge = data.shapes[0].shape as ISubEdgeShape;
+        const points: { intersect: XYZ; location: XYZ }[] = [];
+        trackingDatas.forEach((x) => {
+            edge.intersect(x.axis).forEach((p) => {
+                points.push({ intersect: p.point, location: x.axis.point });
+            });
+        });
+        points.sort((p) => IView.screenDistance(data.view, data.mx, data.my, p.intersect));
+        return points.at(0);
+    }
+
+    private detectTracking(view: IView, x: number, y: number) {
+        const data: TrackingData[] = [];
+        if (this.referencePoint) {
+            const axies = this._axisTracking.getAxes(view, this.referencePoint());
+            data.push(...this.getSnapedFromAxes(axies, view, x, y));
+        }
+        const objectTrackingRays = this._objectTracking.getTrackingRays(view);
+        objectTrackingRays.forEach((a) => {
+            data.push(...this.getSnapedFromAxes(a.axes, view, x, y, a.objectName));
+        });
+        return data;
+    }
+
+    private getSnapedFromAxes(axes: Axis[], view: IView, x: number, y: number, snapedName?: string) {
+        const result: TrackingData[] = [];
+        for (const axis of axes) {
+            const distance = this.rayDistanceAtScreen(view, x, y, axis);
+            if (distance < Config.instance.SnapDistance) {
+                const ray = view.rayAt(x, y);
+                const point = axis.nearestTo(ray.toLine());
+                if (point.sub(axis.point).dot(axis.direction) < 0) continue;
+                result.push({
+                    axis,
+                    distance,
+                    point,
+                    info: snapedName ?? axis.name,
+                    isObjectTracking: snapedName !== undefined,
+                });
+            }
+        }
+        return result;
+    }
+
+    private rayDistanceAtScreen(view: IView, x: number, y: number, axis: Line): number {
+        const start = view.worldToScreen(axis.point);
+        const vector = new XY(x - start.x, y - start.y);
+        if (vector.isEqualTo(XY.zero)) return 0;
+        const end = view.worldToScreen(axis.point.add(axis.direction.multiply(100000)));
+        if (start.distanceTo(end) < Precision.Float) return vector.length();
+        const dir = end.sub(start).normalize()!;
+        const dot = vector.dot(dir);
+        return Math.sqrt(vector.lengthSq() - dot * dot);
+    }
+
+    removeDynamicObject(): void {
+        this._tempLines.forEach((v, k) => {
+            v.forEach((id) => {
+                k.document.visual.context.removeMesh(id);
+            });
+        });
+        this._tempLines.clear();
+    }
+
+    private readonly onSnapTypeChanged = (property: keyof Config): void => {
+        if (property === "snapType" || property === "enableSnapTracking" || property === "enableSnap") {
+            this.removeDynamicObject();
+            this._objectTracking.clear();
+            this._axisTracking.clear();
+        }
+    };
+
+    clear(): void {
+        this.removeDynamicObject();
+        this._axisTracking.clear();
+        this._objectTracking.clear();
+        Config.instance.removePropertyChanged(this.onSnapTypeChanged);
+    }
+}

package/packages/chili/src/step/angleStep.ts

@@ -0,0 +1,32 @@
+// 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, type I18nKeys, type IDocument, Precision, type XYZ } from "chili-core";
+import { AngleSnapEventHandler, Dimension, type PointSnapData } from "../snap";
+import { SnapStep } from "./step";
+
+function defaultSnapedData(): PointSnapData {
+    return {
+        dimension: Dimension.D1D2D3,
+    };
+}
+
+export class AngleStep extends SnapStep<PointSnapData> {
+    constructor(
+        tip: I18nKeys,
+        private readonly handleCenter: () => XYZ,
+        private readonly handleP1: () => XYZ,
+        handleP2Data: () => PointSnapData = defaultSnapedData,
+        keepSelected = false,
+    ) {
+        super(tip, handleP2Data, keepSelected);
+    }
+
+    protected getEventHandler(document: IDocument, controller: AsyncController, data: PointSnapData) {
+        return new AngleSnapEventHandler(document, controller, this.handleCenter, this.handleP1(), data);
+    }
+
+    protected validator(data: PointSnapData, point: XYZ): boolean {
+        return data.refPoint === undefined || data.refPoint().distanceTo(point) > Precision.Distance;
+    }
+}

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

@@ -0,0 +1,8 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./angleStep";
+export * from "./lengthStep";
+export * from "./pointStep";
+export * from "./selectStep";
+export * from "./step";

package/packages/chili/src/step/lengthStep.ts

@@ -0,0 +1,32 @@
+// 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, type IDocument, Precision, type XYZ } from "chili-core";
+import {
+    type LengthAtAxisSnapData,
+    SnapLengthAtAxisHandler,
+    type SnapLengthAtPlaneData,
+    SnapLengthAtPlaneHandler,
+} from "../snap";
+import { SnapStep } from "./step";
+
+export class LengthAtAxisStep extends SnapStep<LengthAtAxisSnapData> {
+    protected getEventHandler(document: IDocument, controller: AsyncController, data: LengthAtAxisSnapData) {
+        return new SnapLengthAtAxisHandler(document, controller, data);
+    }
+
+    protected validator(data: LengthAtAxisSnapData, point: XYZ): boolean {
+        return Math.abs(point.sub(data.point).dot(data.direction)) > Precision.Distance;
+    }
+}
+
+export class LengthAtPlaneStep extends SnapStep<SnapLengthAtPlaneData> {
+    protected getEventHandler(document: IDocument, controller: AsyncController, data: SnapLengthAtPlaneData) {
+        return new SnapLengthAtPlaneHandler(document, controller, data);
+    }
+
+    protected validator(data: SnapLengthAtPlaneData, point: XYZ): boolean {
+        const pointAtPlane = data.plane(point).project(point);
+        return pointAtPlane.distanceTo(data.point()) > Precision.Distance;
+    }
+}

package/packages/chili/src/step/pointStep.ts

@@ -0,0 +1,87 @@
+// 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, type I18nKeys, type IDocument, Precision, type XYZ } from "chili-core";
+import {
+    Dimension,
+    type PointSnapData,
+    PointSnapEventHandler,
+    type SnapPointOnAxisData,
+    SnapPointOnAxisEventHandler,
+    type SnapPointOnCurveData,
+    SnapPointOnCurveEventHandler,
+    SnapPointPlaneEventHandler,
+} from "../snap";
+import { SnapStep } from "./step";
+
+function defaultSnapedData(): PointSnapData {
+    return { dimension: Dimension.D1 | Dimension.D1D2D3 };
+}
+
+export class PointStep extends SnapStep<PointSnapData> {
+    constructor(tip: I18nKeys, handleData: () => PointSnapData = defaultSnapedData, keepSelected = false) {
+        super(tip, handleData, keepSelected);
+    }
+
+    protected getEventHandler(document: IDocument, controller: AsyncController, data: PointSnapData) {
+        return new PointSnapEventHandler(document, controller, data);
+    }
+
+    protected validator(data: PointSnapData, point: XYZ): boolean {
+        return data.refPoint === undefined || data.refPoint().distanceTo(point) > Precision.Distance;
+    }
+}
+
+export class PointOnCurveStep extends SnapStep<SnapPointOnCurveData> {
+    constructor(tip: I18nKeys, handleData: () => SnapPointOnCurveData, keepSelected = false) {
+        super(tip, handleData, keepSelected);
+    }
+
+    protected override validator(data: SnapPointOnCurveData, point: XYZ): boolean {
+        return true;
+    }
+
+    protected override getEventHandler(
+        document: IDocument,
+        controller: AsyncController,
+        data: SnapPointOnCurveData,
+    ) {
+        return new SnapPointOnCurveEventHandler(document, controller, data);
+    }
+}
+
+export class PointOnAxisStep extends SnapStep<SnapPointOnAxisData> {
+    constructor(tip: I18nKeys, handleData: () => SnapPointOnAxisData, keepSelected = false) {
+        super(tip, handleData, keepSelected);
+    }
+
+    protected override validator(data: SnapPointOnAxisData, point: XYZ): boolean {
+        return true;
+    }
+
+    protected override getEventHandler(
+        document: IDocument,
+        controller: AsyncController,
+        data: SnapPointOnAxisData,
+    ) {
+        return new SnapPointOnAxisEventHandler(document, controller, data);
+    }
+}
+
+export class PointOnPlaneStep extends SnapStep<PointSnapData> {
+    constructor(tip: I18nKeys, handleData: () => PointSnapData, keepSelected = false) {
+        super(tip, handleData, keepSelected);
+    }
+
+    protected override validator(data: PointSnapData, point: XYZ): boolean {
+        return true;
+    }
+
+    protected override getEventHandler(
+        document: IDocument,
+        controller: AsyncController,
+        data: SnapPointOnCurveData,
+    ) {
+        return new SnapPointPlaneEventHandler(document, controller, data);
+    }
+}

package/packages/chili/src/step/selectStep.ts

@@ -0,0 +1,130 @@
+// 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,
+    I18nKeys,
+    IDocument,
+    INodeFilter,
+    IShapeFilter,
+    ShapeNode,
+    ShapeType,
+    VisualState,
+} from "chili-core";
+import type { SnapResult } from "../snap";
+import type { IStep } from "./step";
+
+export interface SelectShapeOptions {
+    multiple?: boolean;
+    nodeFilter?: INodeFilter;
+    shapeFilter?: IShapeFilter;
+    selectedState?: VisualState;
+    highlightState?: VisualState;
+    keepSelection?: boolean;
+}
+
+export interface SelectNodeOptions {
+    multiple?: boolean;
+    filter?: INodeFilter;
+    keepSelection?: boolean;
+}
+
+export abstract class SelectStep implements IStep {
+    constructor(
+        readonly snapeType: ShapeType,
+        readonly prompt: I18nKeys,
+        readonly options?: SelectShapeOptions,
+    ) {}
+
+    async execute(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined> {
+        const { shapeType, shapeFilter, nodeFilter } = document.selection;
+        document.selection.shapeType = this.snapeType;
+        document.selection.shapeFilter = this.options?.shapeFilter;
+        document.selection.nodeFilter = this.options?.nodeFilter;
+        if (!this.options?.keepSelection) {
+            document.selection.clearSelection();
+            document.visual.highlighter.clear();
+        }
+
+        return Promise.try(this.select.bind(this), document, controller).finally(() => {
+            document.selection.shapeType = shapeType;
+            document.selection.shapeFilter = shapeFilter;
+            document.selection.nodeFilter = nodeFilter;
+        });
+    }
+
+    abstract select(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined>;
+}
+
+export class SelectShapeStep extends SelectStep {
+    override async select(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined> {
+        const shapes = await document.selection.pickShape(
+            this.prompt,
+            controller,
+            this.options?.multiple === true,
+            this.options?.selectedState,
+            this.options?.highlightState,
+        );
+        if (shapes.length === 0) return undefined;
+        return {
+            view: document.application.activeView!,
+            shapes,
+            nodes: shapes.map((x) => x.owner.node),
+        };
+    }
+}
+
+export class SelectNodeStep implements IStep {
+    constructor(
+        readonly prompt: I18nKeys,
+        readonly options?: SelectNodeOptions,
+    ) {}
+
+    async execute(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined> {
+        const { nodeFilter } = document.selection;
+        document.selection.nodeFilter = this.options?.filter;
+        if (!this.options?.keepSelection) {
+            document.selection.clearSelection();
+            document.visual.highlighter.clear();
+        }
+
+        return Promise.try(async () => {
+            const nodes = await document.selection.pickNode(
+                this.prompt,
+                controller,
+                this.options?.multiple === true,
+            );
+            if (nodes.length === 0) return undefined;
+            return {
+                view: document.application.activeView!,
+                shapes: [],
+                nodes,
+            };
+        }).finally(() => {
+            document.selection.nodeFilter = nodeFilter;
+        });
+    }
+}
+
+export class GetOrSelectNodeStep extends SelectNodeStep {
+    override execute(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined> {
+        const selected = document.selection.getSelectedNodes().filter((x) => {
+            if (this.options?.filter?.allow) {
+                return this.options.filter.allow(x);
+            }
+
+            return true;
+        });
+
+        if (selected.length > 0) {
+            controller.success();
+            return Promise.resolve({
+                view: document.application.activeView!,
+                shapes: [],
+                nodes: selected as ShapeNode[],
+            });
+        }
+
+        return super.execute(document, controller);
+    }
+}

package/packages/chili/src/step/step.ts

@@ -0,0 +1,55 @@
+// 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, CursorType, I18nKeys, IDocument, XYZ } from "chili-core";
+import type { SnapData, SnapEventHandler, SnapResult } from "../snap";
+
+export interface IStep {
+    execute(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined>;
+}
+
+export abstract class SnapStep<D extends SnapData> implements IStep {
+    protected cursor: CursorType = "draw";
+
+    constructor(
+        readonly tip: I18nKeys,
+        private readonly handleStepData: () => D,
+        private readonly keepSelected: boolean = false,
+    ) {}
+
+    async execute(document: IDocument, controller: AsyncController): Promise<SnapResult | undefined> {
+        if (!this.keepSelected) {
+            document.selection.clearSelection();
+            document.visual.highlighter.clear();
+        }
+
+        const data = this.handleStepData();
+        this.setValidator(data);
+
+        const executorHandler = this.getEventHandler(document, controller, data);
+        await document.selection.pickAsync(executorHandler, this.tip, controller, false, this.cursor);
+        const snaped = executorHandler.snaped;
+
+        executorHandler.dispose();
+
+        return controller.result?.status === "success" ? snaped : undefined;
+    }
+
+    private setValidator(data: D) {
+        const oldValidator = data.validator;
+        data.validator = (point) => {
+            if (oldValidator) {
+                return oldValidator(point) && this.validator(data, point);
+            }
+            return this.validator(data, point);
+        };
+    }
+
+    protected abstract getEventHandler(
+        document: IDocument,
+        controller: AsyncController,
+        data: D,
+    ): SnapEventHandler;
+
+    protected abstract validator(data: D, point: XYZ): boolean;
+}