chili3d 0.6.1

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

@@ -0,0 +1,50 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type {
+    IDocument,
+    IShapeFilter,
+    IView,
+    Plane,
+    ShapeMeshData,
+    VisualNode,
+    VisualShapeData,
+    XYZ,
+} from "chili-core";
+
+export interface SnapData {
+    preview?: (point: XYZ | undefined) => ShapeMeshData[];
+    prompt?: (point: SnapResult) => string;
+    filter?: IShapeFilter;
+    validator?: (point: XYZ) => boolean;
+    featurePoints?: {
+        point: XYZ;
+        prompt: string;
+        when?: () => boolean;
+    }[];
+}
+
+export interface SnapResult {
+    view: IView;
+    point?: XYZ;
+    info?: string;
+    distance?: number;
+    refPoint?: XYZ;
+    shapes: VisualShapeData[];
+    nodes?: VisualNode[];
+    plane?: Plane;
+}
+
+export interface MouseAndDetected {
+    view: IView;
+    mx: number;
+    my: number;
+    shapes: VisualShapeData[];
+}
+
+export interface ISnap {
+    snap(data: MouseAndDetected): SnapResult | undefined;
+    readonly handleSnaped?: (document: IDocument, snaped?: SnapResult) => void;
+    removeDynamicObject(): void;
+    clear(): void;
+}

package/packages/chili/src/snap/snaps/axisSnap.ts

@@ -0,0 +1,57 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { EdgeMeshData, type IView, LineType, Plane, VisualConfig, type XYZ } from "chili-core";
+import type { ISnap, MouseAndDetected, SnapResult } from "../snap";
+
+export class AxisSnap implements ISnap {
+    private _tempLines?: [IView, number];
+
+    constructor(
+        readonly point: XYZ,
+        readonly direction: XYZ,
+    ) {}
+
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        const right = data.view.up().cross(data.view.direction()).normalize();
+        const normal = right?.cross(this.direction).normalize();
+        if (!normal) return undefined;
+
+        const plane = new Plane(this.point, normal, right!);
+        const ray = data.view.rayAt(data.mx, data.my);
+        const intersect = plane.intersectRay(ray);
+        if (!intersect) return undefined;
+
+        const vector = intersect.sub(this.point);
+        const dot = vector.dot(this.direction);
+        const point = this.point.add(this.direction.multiply(dot));
+        this.showTempLine(data.view, dot);
+
+        return {
+            view: data.view,
+            point,
+            distance: dot,
+            shapes: [],
+        };
+    }
+
+    private showTempLine(view: IView, dot: number) {
+        const dist = Math.abs(dot) < 0.000001 ? 1e15 : 1e15 * dot;
+        const lineDats = EdgeMeshData.from(
+            this.point,
+            this.point.add(this.direction.multiply(dist)),
+            VisualConfig.temporaryEdgeColor,
+            LineType.Dash,
+        );
+        const id = view.document.visual.context.displayMesh([lineDats]);
+        this._tempLines = [view, id];
+    }
+
+    removeDynamicObject(): void {
+        this._tempLines?.[0].document.visual.context.removeMesh(this._tempLines[1]);
+    }
+
+    clear(): void {
+        this.removeDynamicObject();
+    }
+}

package/packages/chili/src/snap/snaps/baseSnap.ts

@@ -0,0 +1,69 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type IView, type VisualShapeData, VisualState, type XYZ } from "chili-core";
+import type { ISnap, MouseAndDetected, SnapResult } from "../snap";
+
+export abstract class BaseSnap implements ISnap {
+    protected _tempMeshIds: Map<IView, number[]> = new Map();
+    protected _highlightedShapes: VisualShapeData[] = [];
+
+    constructor(readonly referencePoint?: () => XYZ) {}
+
+    abstract snap(data: MouseAndDetected): SnapResult | undefined;
+
+    removeDynamicObject(): void {
+        this.clearTempMeshes();
+        this.unhighlight();
+    }
+
+    clear(): void {
+        this.removeDynamicObject();
+    }
+
+    protected clearTempMeshes(): void {
+        this._tempMeshIds.forEach((ids, view) => {
+            ids.forEach((id) => view.document.visual.context.removeMesh(id));
+        });
+        this._tempMeshIds.clear();
+    }
+
+    protected addTempMesh(view: IView, meshId: number): void {
+        let ids = this._tempMeshIds.get(view);
+        if (!ids) {
+            ids = [];
+            this._tempMeshIds.set(view, ids);
+        }
+        ids.push(meshId);
+    }
+
+    protected highlight(shapes: VisualShapeData[]): void {
+        shapes.forEach((shape) => {
+            const highlighter = shape.owner.node.document.visual.highlighter;
+            highlighter.addState(
+                shape.owner,
+                VisualState.edgeHighlight,
+                shape.shape.shapeType,
+                ...shape.indexes,
+            );
+        });
+        this._highlightedShapes.push(...shapes);
+    }
+
+    protected unhighlight(): void {
+        this._highlightedShapes.forEach((shape) => {
+            const highlighter = shape.owner.node.document.visual.highlighter;
+            highlighter.removeState(
+                shape.owner,
+                VisualState.edgeHighlight,
+                shape.shape.shapeType,
+                ...shape.indexes,
+            );
+        });
+        this._highlightedShapes.length = 0;
+    }
+
+    protected calculateDistance(point: XYZ): number | undefined {
+        return this.referencePoint ? this.referencePoint().distanceTo(point) : undefined;
+    }
+}

package/packages/chili/src/snap/snaps/featurePointStrategy.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 {
+    I18n,
+    type IEdge,
+    type IView,
+    ObjectSnapType,
+    ShapeType,
+    type VisualShapeData,
+    type XYZ,
+} from "chili-core";
+import type { SnapResult } from "../snap";
+
+export class FeaturePointStrategy {
+    private readonly _featureInfos: Map<VisualShapeData, SnapResult[]> = new Map();
+
+    constructor(private _snapType: ObjectSnapType) {}
+
+    getFeaturePoints(view: IView, shape: VisualShapeData): SnapResult[] {
+        if (this._featureInfos.has(shape)) {
+            return this._featureInfos.get(shape)!;
+        }
+
+        const infos: SnapResult[] = [];
+        if (shape.shape.shapeType === ShapeType.Edge) {
+            this.getEdgeFeaturePoints(view, shape, infos);
+        }
+        this._featureInfos.set(shape, infos);
+        return infos;
+    }
+
+    private getEdgeFeaturePoints(view: IView, shape: VisualShapeData, infos: SnapResult[]) {
+        const curve = (shape.shape as IEdge).curve;
+        const start = curve.value(curve.firstParameter());
+        const end = curve.value(curve.lastParameter());
+
+        const addPoint = (point: XYZ, info: string) =>
+            infos.push({
+                view,
+                point: shape.transform.ofPoint(point),
+                info,
+                shapes: [shape],
+            });
+
+        if (ObjectSnapType.has(this._snapType, ObjectSnapType.endPoint)) {
+            addPoint(start, I18n.translate("snap.end"));
+            addPoint(end, I18n.translate("snap.end"));
+        }
+        if (ObjectSnapType.has(this._snapType, ObjectSnapType.midPoint)) {
+            const mid = curve.value((curve.firstParameter() + curve.lastParameter()) * 0.5);
+            addPoint(mid, I18n.translate("snap.mid"));
+        }
+    }
+
+    clear(): void {
+        this._featureInfos.clear();
+    }
+
+    updateSnapType(snapType: ObjectSnapType): void {
+        this._snapType = snapType;
+        this.clear();
+    }
+}

package/packages/chili/src/snap/snaps/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 "./axisSnap";
+export * from "./objectSnap";
+export * from "./planeSnap";
+export * from "./pointOnCurveSnap";

package/packages/chili/src/snap/snaps/objectSnap.ts

@@ -0,0 +1,264 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    Config,
+    I18n,
+    type ICircle,
+    ICurve,
+    type IDocument,
+    type IEdge,
+    IView,
+    type IVisualContext,
+    ObjectSnapType,
+    ShapeType,
+    VertexMeshData,
+    VisualConfig,
+    type VisualShapeData,
+    type XYZ,
+} from "chili-core";
+import type { MouseAndDetected, SnapResult } from "../snap";
+import { BaseSnap } from "./baseSnap";
+import { FeaturePointStrategy } from "./featurePointStrategy";
+
+interface InvisibleSnapInfo {
+    view: IView;
+    snaps: SnapResult[];
+    displays: number[];
+}
+
+export class ObjectSnap extends BaseSnap {
+    private readonly _featureStrategy: FeaturePointStrategy;
+    private readonly _intersectionInfos: Map<string, SnapResult[]>;
+    private readonly _invisibleInfos: Map<VisualShapeData, InvisibleSnapInfo>;
+    private _lastDetected?: [IView, SnapResult];
+    private _hintVertex?: [IVisualContext, number];
+
+    constructor(
+        private _snapType: ObjectSnapType,
+        referencePoint?: () => XYZ,
+    ) {
+        super(referencePoint);
+        this._featureStrategy = new FeaturePointStrategy(_snapType);
+        this._intersectionInfos = new Map();
+        this._invisibleInfos = new Map();
+        Config.instance.onPropertyChanged(this.onSnapTypeChanged);
+    }
+
+    override clear() {
+        super.clear();
+        this._invisibleInfos.forEach((info) => {
+            info.displays.forEach((x) => info.view.document.visual.context.removeMesh(x));
+        });
+        this.removeHint();
+        this._featureStrategy.clear();
+        Config.instance.removePropertyChanged(this.onSnapTypeChanged);
+    }
+
+    readonly handleSnaped = (document: IDocument, snaped?: SnapResult | undefined) => {
+        if (snaped?.shapes.length === 0 && this._lastDetected) {
+            this.displayHint(this._lastDetected[0], this._lastDetected[1]);
+            this._lastDetected = undefined;
+        }
+    };
+
+    private readonly onSnapTypeChanged = (property: keyof Config) => {
+        if (property === "snapType" || property === "enableSnap") {
+            this._snapType = Config.instance.snapType;
+            this._featureStrategy.updateSnapType(this._snapType);
+            this._intersectionInfos.clear();
+        }
+    };
+
+    override removeDynamicObject(): void {
+        super.removeDynamicObject();
+        this.removeHint();
+    }
+
+    private removeHint() {
+        if (this._hintVertex !== undefined) {
+            this._hintVertex[0].removeMesh(this._hintVertex[1]);
+            this._hintVertex = undefined;
+        }
+    }
+
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        if (!Config.instance.enableSnap) return undefined;
+
+        let snap: SnapResult | undefined;
+        if (data.shapes.length > 0) {
+            this.showInvisibleSnaps(data.view, data.shapes[0]);
+            snap = this.snapOnShape(data.view, data.mx, data.my, data.shapes);
+        } else {
+            snap = this.snapeInvisible(data.view, data.mx, data.my);
+        }
+        if (this.referencePoint && snap?.point) {
+            snap.distance = this.referencePoint().distanceTo(snap.point);
+        }
+        return snap;
+    }
+
+    private snapOnShape(view: IView, x: number, y: number, shapes: VisualShapeData[]) {
+        const featurePoints = this._featureStrategy.getFeaturePoints(view, shapes[0]);
+        const perpendiculars = this.findPerpendicular(view, shapes[0]);
+        const intersections = this.getIntersections(view, shapes[0], shapes);
+        const ordered = [...featurePoints, ...perpendiculars, ...intersections].sort((a, b) =>
+            this.sortSnaps(view, x, y, a, b),
+        );
+
+        if (ordered.length === 0) return undefined;
+
+        const dist = IView.screenDistance(view, x, y, ordered[0].point!);
+        if (dist < Config.instance.SnapDistance) {
+            this.hilighted(view, ordered[0].shapes);
+            return ordered[0];
+        } else {
+            this._lastDetected = [view, ordered[0]];
+            return undefined;
+        }
+    }
+
+    private displayHint(view: IView, shape: SnapResult) {
+        this.hilighted(view, shape.shapes);
+        const data = VertexMeshData.from(
+            shape.point!,
+            VisualConfig.hintVertexSize,
+            VisualConfig.hintVertexColor,
+        );
+        this._hintVertex = [view.document.visual.context, view.document.visual.context.displayMesh([data])];
+    }
+
+    private snapeInvisible(view: IView, x: number, y: number): SnapResult | undefined {
+        const { minDistance, snap } = this.getNearestInvisibleSnap(view, x, y);
+        if (minDistance < Config.instance.SnapDistance) {
+            this.hilighted(view, snap!.shapes);
+            return snap;
+        }
+        return undefined;
+    }
+
+    private getNearestInvisibleSnap(
+        view: IView,
+        x: number,
+        y: number,
+    ): { minDistance: number; snap?: SnapResult } {
+        let snap: SnapResult | undefined;
+        let minDistance = Number.MAX_VALUE;
+
+        this._invisibleInfos.forEach((info) => {
+            info.snaps.forEach((s) => {
+                const dist = IView.screenDistance(view, x, y, s.point!);
+                if (dist < minDistance) {
+                    minDistance = dist;
+                    snap = s;
+                }
+            });
+        });
+        return { minDistance, snap };
+    }
+
+    private showInvisibleSnaps(view: IView, shape: VisualShapeData) {
+        if (shape.shape.shapeType === ShapeType.Edge) {
+            if (this._invisibleInfos.has(shape)) return;
+            const curve = (shape.shape as IEdge).curve;
+            const basisCurve = curve.basisCurve;
+            if (ICurve.isCircle(basisCurve)) {
+                this.showCircleCenter(basisCurve, view, shape);
+            }
+        }
+    }
+
+    private showCircleCenter(curve: ICircle, view: IView, shape: VisualShapeData) {
+        const center = shape.transform.ofPoint(curve.center);
+        const temporary = VertexMeshData.from(
+            center,
+            VisualConfig.hintVertexSize,
+            VisualConfig.hintVertexColor,
+        );
+        const id = view.document.visual.context.displayMesh([temporary]);
+        this._invisibleInfos.set(shape, {
+            view,
+            snaps: [
+                {
+                    view,
+                    point: center,
+                    info: I18n.translate("snap.center"),
+                    shapes: [shape],
+                },
+            ],
+            displays: [id],
+        });
+    }
+
+    private hilighted(view: IView, shapes: VisualShapeData[]) {
+        this.highlight(shapes);
+    }
+
+    private sortSnaps(view: IView, x: number, y: number, a: SnapResult, b: SnapResult): number {
+        return IView.screenDistance(view, x, y, a.point!) - IView.screenDistance(view, x, y, b.point!);
+    }
+
+    private findPerpendicular(view: IView, shape: VisualShapeData): SnapResult[] {
+        const result: SnapResult[] = [];
+        if (
+            !ObjectSnapType.has(this._snapType, ObjectSnapType.perpendicular) ||
+            this.referencePoint === undefined
+        ) {
+            return result;
+        }
+
+        const curve = (shape.shape as IEdge).curve;
+        const transform = shape.transform;
+        const point = curve.project(transform.invert()!.ofPoint(this.referencePoint())).at(0);
+        if (point === undefined) return result;
+        result.push({
+            view,
+            point: transform.ofPoint(point),
+            info: I18n.translate("snap.perpendicular"),
+            shapes: [shape],
+        });
+
+        return result;
+    }
+
+    private getIntersections(view: IView, current: VisualShapeData, shapes: VisualShapeData[]) {
+        const result: SnapResult[] = [];
+        if (
+            !ObjectSnapType.has(this._snapType, ObjectSnapType.intersection) ||
+            current.shape.shapeType !== ShapeType.Edge
+        ) {
+            return result;
+        }
+        shapes.forEach((x) => {
+            if (x === current || x.shape.shapeType !== ShapeType.Edge) return;
+            const key = this.getIntersectionKey(current, x);
+            let arr = this._intersectionInfos.get(key);
+            if (arr === undefined) {
+                arr = this.findIntersections(view, current, x);
+                this._intersectionInfos.set(key, arr);
+            }
+            result.push(...arr);
+        });
+        return result;
+    }
+
+    private getIntersectionKey(s1: VisualShapeData, s2: VisualShapeData) {
+        return s1.shape.id < s2.shape.id ? `${s1.shape.id}:${s2.shape.id}` : `${s2.shape.id}:${s1.shape.id}`;
+    }
+
+    private findIntersections(view: IView, s1: VisualShapeData, s2: VisualShapeData): SnapResult[] {
+        const e1 = s1.shape.transformedMul(s1.transform) as IEdge;
+        const e2 = s2.shape.transformedMul(s2.transform) as IEdge;
+        const intersections = e1.intersect(e2);
+        e1.dispose();
+        e2.dispose();
+        return intersections.map((point) => {
+            return {
+                view,
+                point: point.point,
+                info: I18n.translate("snap.intersection"),
+                shapes: [s1, s2],
+            };
+        });
+    }
+}

package/packages/chili/src/snap/snaps/planeSnap.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 { Plane, XYZ } from "chili-core";
+import { ViewUtils } from "chili-vis";
+import type { ISnap, MouseAndDetected, SnapResult } from "../snap";
+
+export abstract class PlaneSnapBase implements ISnap {
+    removeDynamicObject(): void {}
+    clear(): void {}
+    abstract snap(data: MouseAndDetected): SnapResult | undefined;
+
+    constructor(readonly refPoint?: () => XYZ) {}
+
+    protected snapAtPlane(plane: Plane, data: MouseAndDetected): SnapResult | undefined {
+        plane = ViewUtils.ensurePlane(data.view, plane);
+        const ray = data.view.rayAt(data.mx, data.my);
+        const point = plane.intersectRay(ray);
+        if (!point) return undefined;
+
+        const distance = this.refPoint ? this.refPoint().distanceTo(point) : undefined;
+
+        return {
+            view: data.view,
+            point,
+            distance,
+            shapes: [],
+        };
+    }
+}
+
+export class WorkplaneSnap extends PlaneSnapBase {
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        return this.snapAtPlane(data.view.workplane, data);
+    }
+}
+
+export class PlaneSnap extends PlaneSnapBase {
+    constructor(
+        readonly plane: (point: XYZ) => Plane,
+        refPoint?: () => XYZ,
+    ) {
+        super(refPoint);
+    }
+
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        const point = data.view.screenToWorld(data.mx, data.my);
+        const plane = this.plane(point);
+        const result = this.snapAtPlane(plane, data);
+        if (result) {
+            result.plane = plane;
+        }
+        return result;
+    }
+}

package/packages/chili/src/snap/snaps/pointOnCurveSnap.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 type { SnapPointOnCurveData } from "../handlers";
+import type { ISnap, MouseAndDetected, SnapResult } from "../snap";
+
+export class PointOnCurveSnap implements ISnap {
+    constructor(readonly pointData: SnapPointOnCurveData) {}
+
+    snap(data: MouseAndDetected): SnapResult | undefined {
+        const ray = data.view.rayAt(data.mx, data.my);
+        const curve = this.pointData.curve;
+        const nearest = curve.nearestExtrema(ray.toLine());
+        if (!nearest) return undefined;
+        return {
+            view: data.view,
+            point: nearest.p1,
+            shapes: [],
+        };
+    }
+
+    removeDynamicObject(): void {}
+    clear(): void {}
+}

package/packages/chili/src/snap/tracking/axis.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 { I18n, type I18nKeys, Line, type Plane, type XYZ } from "chili-core";
+
+export class Axis extends Line {
+    constructor(
+        location: XYZ,
+        direction: XYZ,
+        readonly name: string,
+    ) {
+        super(location, direction);
+    }
+
+    static getAxiesAtPlane(location: XYZ, plane: Plane, containsZ: boolean) {
+        const createAxis = (direction: XYZ, name: I18nKeys) =>
+            new Axis(location, direction, I18n.translate(name));
+
+        const axies = [
+            createAxis(plane.xvec, "axis.x"),
+            createAxis(plane.xvec.reverse(), "axis.x"),
+            createAxis(plane.yvec, "axis.y"),
+            createAxis(plane.yvec.reverse(), "axis.y"),
+        ];
+
+        if (containsZ) {
+            axies.push(createAxis(plane.normal, "axis.z"), createAxis(plane.normal.reverse(), "axis.z"));
+        }
+
+        return axies;
+    }
+}

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

@@ -0,0 +1,46 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { I18n, type IView, type Plane, type XYZ } from "chili-core";
+import { Axis } from "./axis";
+import { TrackingBase } from "./trackingBase";
+
+export class AxisTracking extends TrackingBase {
+    private readonly axies: Map<IView, Axis[]> = new Map();
+
+    constructor(trackingZ: boolean) {
+        super(trackingZ);
+    }
+
+    getAxes(view: IView, referencePoint: XYZ, angle: number | undefined = undefined) {
+        if (!this.axies.has(view)) {
+            this.axies.set(view, this.initAxes(view.workplane, referencePoint, angle));
+        }
+        return this.axies.get(view)!;
+    }
+
+    private initAxes(plane: Plane, referencePoint: XYZ, angle: number | undefined): Axis[] {
+        if (angle === undefined) {
+            return Axis.getAxiesAtPlane(referencePoint, plane, this.trackingZ);
+        }
+
+        const result: Axis[] = [];
+        let testAngle = 0;
+        while (testAngle < 360) {
+            const direction = plane.xvec.rotate(plane.normal, (testAngle / 180) * Math.PI)!;
+            result.push(new Axis(referencePoint, direction, `${testAngle} °`));
+            testAngle += angle;
+        }
+        if (this.trackingZ) {
+            result.push(new Axis(referencePoint, plane.normal, I18n.translate("axis.z")));
+            result.push(new Axis(referencePoint, plane.normal.reverse(), I18n.translate("axis.z")));
+        }
+
+        return result;
+    }
+
+    override clear(): void {
+        super.clear();
+        this.axies.clear();
+    }
+}

package/packages/chili/src/snap/tracking/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 "./axisTracking";
+export * from "./objectTracking";
+export * from "./trackingSnap";