chili3d 0.6.1

package/packages/chili-core/src/visual/meshUtils.ts

@@ -0,0 +1,276 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { MathUtils, type Matrix4 } from "../math";
+import { concatTypedArrays, type EdgeMeshData, type FaceMeshData, type Mesh } from "../shape";
+
+export class MeshUtils {
+    static setFaceMeshData(
+        data: FaceMeshData,
+        other: FaceMeshData | undefined,
+        matrix: Matrix4,
+        offset: { facePosition: number; faceIndex: number },
+    ) {
+        if (!other) {
+            return;
+        }
+
+        data.range = data.range.concat(
+            other.range.map((g) => {
+                return {
+                    start: g.start + offset.faceIndex,
+                    shape: g.shape,
+                    count: g.count,
+                    transform: matrix,
+                };
+            }),
+        );
+        data.index.set(
+            other.index.map((x) => x + offset.facePosition),
+            offset.faceIndex,
+        );
+        data.position.set(matrix.ofPoints(other.position), offset.facePosition * 3);
+        data.normal.set(matrix.ofVectors(other.normal), offset.facePosition * 3);
+        data.uv.set(other.uv, offset.facePosition * 2);
+    }
+
+    static setSurfaceMeshData(
+        data: Mesh,
+        other: Mesh,
+        matrix: Matrix4,
+        offset: { meshPosition: number; meshIndex: number },
+        materialMap: Map<number, number>,
+    ) {
+        other.groups.forEach((g) => {
+            data.groups.push({
+                start: g.start + offset.meshIndex,
+                count: g.count,
+                materialIndex: materialMap.get(g.materialIndex)!,
+            });
+        });
+        if (data.index && other.index) {
+            data.index.set(
+                other.index.map((x) => x + offset.meshPosition),
+                offset.meshIndex,
+            );
+        }
+        if (data.position && other.position) {
+            data.position.set(matrix.ofPoints(other.position), offset.meshPosition * 3);
+        }
+        if (data.normal && other.normal) {
+            data.normal.set(matrix.ofVectors(other.normal), offset.meshPosition * 3);
+        }
+        if (data.uv && other.uv) {
+            data.uv.set(other.uv, offset.meshPosition * 2);
+        }
+    }
+
+    static combineFaceMeshData(data: FaceMeshData, other: FaceMeshData | undefined, matrix: Matrix4) {
+        if (!other) {
+            return;
+        }
+
+        data.range = data.range.concat(
+            other.range.map((g) => {
+                return {
+                    start: g.start + data.index.length,
+                    shape: g.shape,
+                    count: g.count,
+                    transform: matrix,
+                };
+            }),
+        );
+        data.index = concatTypedArrays([data.index, other.index.map((x) => x + data.position.length / 3)]);
+        data.position = MeshUtils.concatFloat32Array(data.position, matrix.ofPoints(other.position));
+        data.normal = MeshUtils.concatFloat32Array(data.normal, matrix.ofVectors(other.normal));
+        data.uv = MeshUtils.concatFloat32Array(data.uv, other.uv);
+    }
+
+    static concatFloat32Array(arr1: ArrayLike<number>, arr2: ArrayLike<number>) {
+        const arr = new Float32Array(arr1.length + arr2.length);
+        arr.set(arr1);
+        arr.set(arr2, arr1.length);
+        return arr;
+    }
+
+    static setEdgeMeshData(
+        data: EdgeMeshData,
+        other: EdgeMeshData | undefined,
+        matrix: Matrix4,
+        offset: number,
+    ) {
+        if (!other) {
+            return;
+        }
+
+        data.position.set(matrix.ofPoints(other.position), offset * 3);
+        data.range = data.range.concat(
+            other.range.map((g) => {
+                return {
+                    transform: matrix,
+                    start: g.start + offset,
+                    shape: g.shape,
+                    count: g.count,
+                };
+            }),
+        );
+    }
+
+    static combineEdgeMeshData(data: EdgeMeshData, other: EdgeMeshData | undefined, matrix: Matrix4) {
+        if (!other) {
+            return;
+        }
+
+        const start = data.position.length / 3;
+        data.position = MeshUtils.concatFloat32Array(data.position, matrix.ofPoints(other.position));
+        data.range = data.range.concat(
+            other.range.map((g) => {
+                return {
+                    start: g.start + start,
+                    shape: g.shape,
+                    count: g.count,
+                    transform: matrix,
+                };
+            }),
+        );
+    }
+
+    static mergeFaceMesh(mesh: FaceMeshData, materialMap: [number, number][]): FaceMeshData {
+        if (materialMap.length === 0) {
+            return mesh;
+        }
+
+        const materialIndexMap = new Map<number, number>(materialMap);
+        for (let i = 0; i < mesh.range.length; i++) {
+            if (!materialIndexMap.has(i)) {
+                materialIndexMap.set(i, 0);
+            }
+        }
+
+        return MeshUtils.mergeFaceMeshWithMap(mesh, materialIndexMap);
+    }
+
+    private static mergeFaceMeshWithMap(mesh: FaceMeshData, materialMap: Map<number, number>): FaceMeshData {
+        const result: FaceMeshData = {
+            position: new Float32Array(mesh.position.length),
+            normal: new Float32Array(mesh.normal.length),
+            uv: new Float32Array(mesh.uv.length),
+            index: new Uint32Array(mesh.index.length),
+            range: [],
+            color: mesh.color,
+            groups: [],
+        };
+
+        const offset = { facePosition: 0, faceIndex: 0 };
+        const grouped = Object.groupBy(materialMap, (x) => x[1]);
+
+        for (const key of Object.keys(grouped)) {
+            const i = parseInt(key);
+            const groupStart = offset.faceIndex;
+            MeshUtils.mergeSameGroup(grouped[i]!, mesh, result, offset);
+            result.groups.push({
+                start: groupStart,
+                count: offset.faceIndex - groupStart,
+                materialIndex: i,
+            });
+        }
+        return result;
+    }
+
+    private static mergeSameGroup(
+        group: [number, number][],
+        mesh: FaceMeshData,
+        result: FaceMeshData,
+        offset: { facePosition: number; faceIndex: number },
+    ) {
+        for (const index of group) {
+            const { start, count, shape, transform: worldTransform } = mesh.range[index[0]];
+
+            const oldIndex = mesh.index.slice(start, start + count);
+            const { min, max } = MathUtils.minMax(oldIndex)!;
+            result.position.set(mesh.position.slice(min * 3, (max + 1) * 3), offset.facePosition * 3);
+            result.normal.set(mesh.normal.slice(min * 3, (max + 1) * 3), offset.facePosition * 3);
+            result.uv.set(mesh.uv.slice(min * 2, (max + 1) * 2), offset.facePosition * 2);
+            result.index.set(
+                oldIndex.map((x) => x - min + offset.facePosition),
+                offset.faceIndex,
+            );
+            result.range.push({
+                start: offset.faceIndex,
+                count,
+                shape,
+                transform: worldTransform,
+            });
+            offset.facePosition += max - min + 1;
+            offset.faceIndex += oldIndex.length;
+        }
+    }
+
+    static subFace(mesh: FaceMeshData, index: number): FaceMeshData | undefined {
+        const group = mesh?.range[index];
+        if (!group) return undefined;
+
+        const indices = mesh.index.slice(group.start, group.start + group.count);
+        const { min, max } = MathUtils.minMax(indices)!;
+        const [indiceStart, indiceEnd] = [min, max + 1];
+
+        return {
+            position: mesh.position.slice(indiceStart * 3, indiceEnd * 3),
+            normal: mesh.normal.slice(indiceStart * 3, indiceEnd * 3),
+            index: indices.map((i) => i - indiceStart),
+            uv: mesh.uv.slice(indiceStart * 2, indiceEnd * 2),
+            range: [],
+            color: mesh.color,
+            groups: [],
+        };
+    }
+
+    static subFaceOutlines(face: FaceMeshData, index: number) {
+        const mesh = MeshUtils.subFace(face, index);
+        if (!mesh) return undefined;
+
+        return MeshUtils.faceOutline(mesh);
+    }
+
+    static addEdge(
+        pointsMap: Map<string, { count: number; points: number[] }>,
+        face: { position: Float32Array },
+        i: number,
+        j: number,
+    ) {
+        const key = i < j ? `${i}_${j}` : `${j}_${i}`;
+        const entry = pointsMap.get(key);
+        if (entry) {
+            entry.count++;
+        } else {
+            const points = [
+                ...face.position.slice(i * 3, i * 3 + 3),
+                ...face.position.slice(j * 3, j * 3 + 3),
+            ];
+            pointsMap.set(key, { count: 1, points });
+        }
+    }
+
+    static faceOutline(face: { position: Float32Array; index: Uint32Array }) {
+        const pointsMap = new Map<string, { count: number; points: number[] }>();
+
+        for (let i = 0; i < face.index.length; i += 3) {
+            MeshUtils.addEdge(pointsMap, face, face.index[i], face.index[i + 1]);
+            MeshUtils.addEdge(pointsMap, face, face.index[i + 1], face.index[i + 2]);
+            MeshUtils.addEdge(pointsMap, face, face.index[i + 2], face.index[i]);
+        }
+
+        return new Float32Array(
+            Array.from(pointsMap.values())
+                .filter((v) => v.count === 1)
+                .flatMap((entry) => entry.points),
+        );
+    }
+
+    static subEdge(mesh: EdgeMeshData, index: number) {
+        const group = mesh?.range[index];
+        if (!group) return undefined;
+
+        return mesh.position.slice(group.start * 3, (group.start + group.count) * 3);
+    }
+}

package/packages/chili-core/src/visual/textGenerator.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.
+
+import type { IVisualObject } from "./visualObject";
+
+export interface ITextGenerator {
+    generate(text: string, size: number, color: number, font: "fzhei"): Promise<IVisualObject>;
+}

package/packages/chili-core/src/visual/view.ts

@@ -0,0 +1,80 @@
+// 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 } from "../document";
+import type { IDisposable, IPropertyChanged } from "../foundation";
+import type { Plane, Ray, XY, XYLike, XYZ, XYZLike } from "../math";
+import type { INodeFilter, IShapeFilter } from "../selectionFilter";
+import type { ShapeType } from "../shape";
+import type { ICameraController } from "./cameraController";
+import type { VisualShapeData } from "./detectedData";
+import type { IVisualObject } from "./visualObject";
+
+export enum ViewMode {
+    solid,
+    wireframe,
+    solidAndWireframe,
+}
+
+export type HtmlTextOptions = {
+    hideDelete?: boolean;
+    className?: string;
+    center?: XYLike;
+    onDispose?: () => void;
+};
+
+export interface IView extends IPropertyChanged, IDisposable {
+    readonly document: IDocument;
+    readonly cameraController: ICameraController;
+    get isClosed(): boolean;
+    get width(): number;
+    get height(): number;
+    get dom(): HTMLElement | undefined;
+    mode: ViewMode;
+    name: string;
+    workplane: Plane;
+    update(): void;
+    up(): XYZ;
+    toImage(): string;
+    direction(): XYZ;
+    rayAt(mx: number, my: number): Ray;
+    screenToWorld(mx: number, my: number): XYZ;
+    worldToScreen(point: XYZ): XY;
+    resize(width: number, heigth: number): void;
+    setDom(element: HTMLElement): void;
+    htmlText(text: string, point: XYZLike, options?: HtmlTextOptions): IDisposable;
+    close(): void;
+    detectVisual(x: number, y: number, nodeFilter?: INodeFilter): IVisualObject[];
+    detectVisualRect(
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number,
+        nodeFilter?: INodeFilter,
+    ): IVisualObject[];
+    detectShapes(
+        shapeType: ShapeType,
+        x: number,
+        y: number,
+        shapeFilter?: IShapeFilter,
+        nodeFilter?: INodeFilter,
+    ): VisualShapeData[];
+    detectShapesRect(
+        shapeType: ShapeType,
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number,
+        shapeFilter?: IShapeFilter,
+        nodeFilter?: INodeFilter,
+    ): VisualShapeData[];
+}
+
+export namespace IView {
+    export function screenDistance(view: IView, mx: number, my: number, point: XYZ) {
+        const xy = view.worldToScreen(point);
+        const dx = xy.x - mx;
+        const dy = xy.y - my;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+}

package/packages/chili-core/src/visual/viewGizmo.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 interface IViewGizmo {
+    update(): void;
+    setDom(dom: HTMLElement): void;
+    dispose(): void;
+}

package/packages/chili-core/src/visual/viewport.ts

@@ -0,0 +1,10 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export enum ViewportsType {
+    Single,
+    TB11,
+    LR11,
+    LR21,
+    Four,
+}

package/packages/chili-core/src/visual/visual.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 { IDocument } from "../document";
+import type { IDisposable } from "../foundation";
+import type { Plane } from "../math";
+import type { IEventHandler } from "./eventHandler";
+import type { IHighlighter } from "./highlighter";
+import type { IMeshExporter } from "./meshExporter";
+import type { IView } from "./view";
+import type { IVisualContext } from "./visualContext";
+
+export interface IVisual extends IDisposable {
+    readonly document: IDocument;
+    readonly context: IVisualContext;
+    readonly viewHandler: IEventHandler;
+    readonly highlighter: IHighlighter;
+    readonly meshExporter: IMeshExporter;
+    update(): void;
+    eventHandler: IEventHandler;
+    resetEventHandler(): void;
+    isExcutingHandler(): boolean;
+    createView(name: string, workplane: Plane): IView;
+}

package/packages/chili-core/src/visual/visualContext.ts

@@ -0,0 +1,29 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IDisposable } from "../foundation";
+import type { BoundingBox, Matrix4 } from "../math";
+import type { INode } from "../model";
+import type { IShapeFilter } from "../selectionFilter";
+import type { EdgeMeshData, MeshLike, ShapeMeshData } from "../shape";
+import type { IVisualObject } from "./visualObject";
+
+export interface IVisualContext extends IDisposable {
+    get shapeCount(): number;
+    addVisualObject(object: IVisualObject): void;
+    boundingBoxIntersectFilter(boundingBox: BoundingBox, filter?: IShapeFilter): IVisualObject[];
+    removeVisualObject(object: IVisualObject): void;
+    addNode(nodes: INode[]): void;
+    removeNode(nodes: INode[]): void;
+    getVisual(node: INode): IVisualObject | undefined;
+    getNode(visual: IVisualObject): INode | undefined;
+    redrawNode(nodes: INode[]): void;
+    setVisible(node: INode, visible: boolean): void;
+    visuals(): IVisualObject[];
+    displayMesh(datas: ShapeMeshData[], opacity?: number): number;
+    removeMesh(id: number): void;
+    displayInstancedMesh(data: MeshLike, matrixs: Matrix4[], opacity?: number): number;
+    displayLineSegments(data: EdgeMeshData): number;
+    setPosition(id: number, position: Float32Array): void;
+    setInstanceMatrix(id: number, matrixs: Matrix4[]): void;
+}

package/packages/chili-core/src/visual/visualFactory.ts

@@ -0,0 +1,10 @@
+// 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 } from "../document";
+import type { IVisual } from "./visual";
+
+export interface IVisualFactory {
+    readonly kernelName: string;
+    create(document: IDocument): IVisual;
+}

package/packages/chili-core/src/visual/visualObject.ts

@@ -0,0 +1,25 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { BoundingBox, GeometryNode, IDisposable, Matrix4, VisualNode } from "chili-core";
+
+export interface IVisualObject extends IDisposable {
+    visible: boolean;
+    transform: Matrix4;
+    worldTransform(): Matrix4;
+    boundingBox(): BoundingBox | undefined;
+}
+
+export interface INodeVisual extends IVisualObject {
+    get node(): VisualNode;
+}
+
+export interface IVisualGeometry extends IVisualObject {
+    get geometryNode(): GeometryNode;
+}
+
+export namespace IVisualObject {
+    export function isGeometry(obj: IVisualObject): obj is IVisualGeometry {
+        return (obj as IVisualGeometry).geometryNode !== undefined;
+    }
+}

package/packages/chili-core/src/visual/visualShape.ts

@@ -0,0 +1,30 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export enum VisualState {
+    normal = 0,
+    edgeHighlight = 1,
+    edgeSelected = 1 << 1,
+    faceTransparent = 1 << 2,
+    faceColored = 1 << 3,
+}
+
+export namespace VisualState {
+    export function addState(origin: VisualState, add: VisualState) {
+        return origin | add;
+    }
+
+    export function removeState(origin: VisualState, remove: VisualState) {
+        return (origin & remove) ^ origin;
+    }
+
+    export function hasState(origin: VisualState, testState: VisualState) {
+        return (origin & testState) === testState;
+    }
+}
+
+export interface VisualGroup {
+    start: number;
+    count: number;
+    materialIndex?: number;
+}

package/packages/chili-core/test/binding.test.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 { Observable, PathBinding } from "../src";
+
+class TestObjectValue extends Observable {
+    get value(): string | undefined {
+        return this.getPrivateValue("value", "value");
+    }
+    set value(value: string | undefined) {
+        this.setProperty("value", value);
+    }
+}
+
+class TestObjectA extends Observable {
+    get propA(): TestObjectValue | undefined {
+        return this.getPrivateValue("propA");
+    }
+    set propA(value: TestObjectValue | undefined) {
+        this.setProperty("propA", value);
+    }
+}
+
+class TestObjectB extends Observable {
+    get propB(): TestObjectA | undefined {
+        return this.getPrivateValue("propB");
+    }
+    set propB(value: TestObjectA | undefined) {
+        this.setProperty("propB", value);
+    }
+
+    get propC(): string | undefined {
+        return this.getPrivateValue("propC", "propC");
+    }
+    set propC(value: string | undefined) {
+        this.setProperty("propC", value);
+    }
+}
+
+describe("PathBinding test", () => {
+    test("test PathBinding1", () => {
+        const obj2 = new TestObjectB();
+        const binding = new PathBinding(obj2, "propB.propA.value");
+        const target = { value: "v1" };
+        binding.setBinding(target, "value");
+        expect(target.value).toBe("v1");
+        obj2.propB = new TestObjectA();
+        expect(target.value).toBe("v1");
+
+        const obj3 = new TestObjectValue();
+        obj2.propB.propA = obj3;
+        expect(target.value).toBe("value");
+        obj2.propB.propA.value = "value2";
+        expect(target.value).toBe("value2");
+
+        obj2.propB = undefined;
+        expect(target.value).toBe("value2");
+        obj3.value = "value3";
+        expect(target.value).toBe("value2");
+
+        obj2.propB = new TestObjectA();
+        expect(target.value).toBe("value2");
+        obj2.propB.propA = new TestObjectValue();
+        expect(target.value).toBe("value");
+        obj2.propB.propA = obj3;
+        expect(target.value).toBe("value3");
+
+        obj2.propB = undefined;
+        expect(target.value).toBe("value3");
+        obj3.value = "value";
+        expect(target.value).toBe("value3");
+
+        obj2.propB = new TestObjectA();
+        obj2.propB.propA = obj3;
+        expect(target.value).toBe("value");
+        obj3.value = "value4";
+        expect(target.value).toBe("value4");
+    });
+
+    test("test PathBinding2", () => {
+        const obj = new TestObjectB();
+        obj.propB = new TestObjectA();
+        obj.propB.propA = new TestObjectValue();
+        const target = { value1: "v1", value2: "v2" };
+        const binding1 = new PathBinding(obj, "propB.propA.value");
+        binding1.setBinding(target, "value1");
+        expect(target.value1).toBe("value");
+
+        const binding2 = new PathBinding(obj, "propC");
+        binding2.setBinding(target, "value2");
+        expect(target.value2).toBe("propC");
+        obj.propC = "propC2";
+        expect(target.value2).toBe("propC2");
+    });
+});

package/packages/chili-core/test/boundingBox.test.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 { BoundingBox, type PointLike } from "../src/math/boundingBox";
+
+describe("BoundingBox.isIntersect", () => {
+    function box(min: PointLike, max: PointLike) {
+        return new BoundingBox(min, max);
+    }
+
+    it("returns true for overlapping boxes", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 2, y: 2, z: 2 });
+        const b = box({ x: 1, y: 1, z: 1 }, { x: 3, y: 3, z: 3 });
+        expect(BoundingBox.isIntersect(a, b)).toBe(true);
+        expect(BoundingBox.isIntersect(b, a)).toBe(true);
+    });
+
+    it("returns false for non-overlapping boxes", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+        const b = box({ x: 2, y: 2, z: 2 }, { x: 3, y: 3, z: 3 });
+        expect(BoundingBox.isIntersect(a, b)).toBe(false);
+        expect(BoundingBox.isIntersect(b, a)).toBe(false);
+    });
+
+    it("returns false for boxes touching at the edge within tolerance", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+        const b = box({ x: 1, y: 1, z: 1 }, { x: 2, y: 2, z: 2 });
+        expect(BoundingBox.isIntersect(a, b, -0.0001)).toBe(false);
+    });
+
+    it("returns false for boxes just outside tolerance", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+        const b = box({ x: 1.002, y: 1.002, z: 1.002 }, { x: 2, y: 2, z: 2 });
+        expect(BoundingBox.isIntersect(a, b)).toBe(false);
+    });
+
+    it("returns true for boxes just within tolerance", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+        const b = box({ x: 1.0005, y: 1.0005, z: 1.0005 }, { x: 2, y: 2, z: 2 });
+        expect(BoundingBox.isIntersect(a, b, 0.001)).toBe(true);
+    });
+
+    it("works with negative coordinates", () => {
+        const a = box({ x: -3, y: -3, z: -3 }, { x: -1, y: -1, z: -1 });
+        const b = box({ x: -2, y: -2, z: -2 }, { x: 0, y: 0, z: 0 });
+        expect(BoundingBox.isIntersect(a, b)).toBe(true);
+    });
+
+    it("returns true for identical boxes", () => {
+        const a = box({ x: 1, y: 1, z: 1 }, { x: 2, y: 2, z: 2 });
+        expect(BoundingBox.isIntersect(a, a)).toBe(true);
+    });
+
+    it("respects custom tolerance", () => {
+        const a = box({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+        const b = box({ x: 1.01, y: 1.01, z: 1.01 }, { x: 2, y: 2, z: 2 });
+        expect(BoundingBox.isIntersect(a, b, 0.02)).toBe(true);
+        expect(BoundingBox.isIntersect(a, b, 0.001)).toBe(false);
+    });
+});