chili3d 0.6.1

package/packages/chili-core/src/model/shapeNode.ts

@@ -0,0 +1,195 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { VisualConfig } from "../config";
+import type { IDocument } from "../document";
+import { Id, type IEqualityComparer, Logger, PubSub, Result } from "../foundation";
+import { I18n, type I18nKeys } from "../i18n";
+import { Matrix4 } from "../math";
+import { Serializer } from "../serialize";
+import { type EdgeMeshData, type FaceMeshData, type IShape, type IShapeMeshData, LineType } from "../shape";
+import { MeshUtils } from "../visual/meshUtils";
+import { GeometryNode } from "./geometryNode";
+
+const SHAPE_UNDEFINED = "Shape not initialized";
+
+export abstract class ShapeNode extends GeometryNode {
+    protected _shape: Result<IShape> = Result.err(SHAPE_UNDEFINED);
+    get shape(): Result<IShape> {
+        return this._shape;
+    }
+
+    protected setShape(shape: Result<IShape>) {
+        if (this._shape.isOk && this._shape.value.isEqual(shape.value)) {
+            return;
+        }
+
+        if (!shape.isOk) {
+            PubSub.default.pub("displayError", shape.error);
+            return;
+        }
+
+        const oldShape = this._shape;
+        this._shape = shape;
+        this._mesh = undefined;
+
+        this.emitPropertyChanged("shape", oldShape);
+
+        oldShape.unchecked()?.dispose();
+    }
+
+    protected override createMesh(): IShapeMeshData {
+        if (!this.shape.isOk) {
+            Logger.warn(this.shape.error);
+            return { edges: undefined, faces: undefined };
+        }
+        const mesh = this.shape.value.mesh;
+        this._originFaceMesh = mesh.faces;
+        if (mesh.faces)
+            mesh.faces = MeshUtils.mergeFaceMesh(
+                mesh.faces,
+                this.faceMaterialPair.map((x) => [x.faceIndex, x.materialIndex]),
+            );
+        return mesh;
+    }
+
+    override disposeInternal(): void {
+        super.disposeInternal();
+        this._shape.unchecked()?.dispose();
+        this._shape = null as any;
+    }
+}
+
+export class MultiShapeMesh implements IShapeMeshData {
+    private readonly _edges: EdgeMeshData;
+    private readonly _faces: FaceMeshData;
+
+    get edges() {
+        return this._edges.position.length > 0 ? this._edges : undefined;
+    }
+
+    get faces() {
+        return this._faces.position.length > 0 ? this._faces : undefined;
+    }
+
+    constructor() {
+        this._edges = {
+            lineType: LineType.Solid,
+            position: new Float32Array(),
+            range: [],
+            color: VisualConfig.defaultEdgeColor,
+        };
+
+        this._faces = {
+            index: new Uint32Array(),
+            normal: new Float32Array(),
+            position: new Float32Array(),
+            uv: new Float32Array(),
+            range: [],
+            groups: [],
+            color: VisualConfig.defaultFaceColor,
+        };
+    }
+
+    public addShape(shape: IShape, matrix: Matrix4) {
+        const mesh = shape.mesh;
+        const totleMatrix = shape.matrix.multiply(matrix);
+        if (mesh.faces) {
+            MeshUtils.combineFaceMeshData(this._faces, mesh.faces, totleMatrix);
+        }
+        if (mesh.edges) {
+            MeshUtils.combineEdgeMeshData(this._edges, mesh.edges, totleMatrix);
+        }
+    }
+}
+
+@Serializer.register(["document", "name", "shapes", "materialId", "id"])
+export class MultiShapeNode extends GeometryNode {
+    private readonly _shapes: IShape[];
+    @Serializer.serialze()
+    get shapes(): ReadonlyArray<IShape> {
+        return this._shapes;
+    }
+
+    constructor(
+        document: IDocument,
+        name: string,
+        shapes: IShape[],
+        materialId?: string,
+        id: string = Id.generate(),
+    ) {
+        super(document, name, materialId, id);
+        this._shapes = shapes;
+    }
+
+    protected override createMesh(): IShapeMeshData {
+        const meshes = new MultiShapeMesh();
+
+        this._shapes.forEach((shape) => {
+            meshes.addShape(shape, Matrix4.identity());
+        });
+
+        return meshes;
+    }
+
+    override display(): I18nKeys {
+        return "body.multiShape";
+    }
+}
+
+export abstract class ParameterShapeNode extends ShapeNode {
+    override get shape(): Result<IShape> {
+        if (!this._shape.isOk && this._shape.error === SHAPE_UNDEFINED) {
+            this._shape = this.generateShape();
+        }
+        return this._shape;
+    }
+
+    protected setPropertyEmitShapeChanged<K extends keyof this>(
+        property: K,
+        newValue: this[K],
+        onPropertyChanged?: (property: K, oldValue: this[K]) => void,
+        equals?: IEqualityComparer<this[K]> | undefined,
+    ): boolean {
+        if (this.setProperty(property, newValue, onPropertyChanged, equals)) {
+            this.setShape(this.generateShape());
+            return true;
+        }
+
+        return false;
+    }
+
+    constructor(document: IDocument, materialId?: string, id?: string) {
+        super(document, undefined as any, materialId, id);
+        this.setPrivateValue("name", I18n.translate(this.display()));
+    }
+
+    protected abstract generateShape(): Result<IShape>;
+}
+
+@Serializer.register(["document", "name", "shape", "materialId", "id"])
+export class EditableShapeNode extends ShapeNode {
+    override display(): I18nKeys {
+        return "body.editableShape";
+    }
+
+    @Serializer.serialze()
+    override get shape() {
+        return this._shape;
+    }
+
+    override set shape(shape: Result<IShape>) {
+        this.setShape(shape);
+    }
+
+    constructor(
+        document: IDocument,
+        name: string,
+        shape: IShape | Result<IShape>,
+        materialId?: string | string[],
+        id?: string,
+    ) {
+        super(document, name, materialId, id);
+        this._shape = shape instanceof Result ? shape : Result.ok(shape);
+    }
+}

package/packages/chili-core/src/model/visualNode.ts

@@ -0,0 +1,39 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { I18nKeys } from "../i18n";
+import { type BoundingBox, Matrix4 } from "../math";
+import { Serializer } from "../serialize";
+import { Node } from "./node";
+
+export abstract class VisualNode extends Node {
+    abstract display(): I18nKeys;
+
+    @Serializer.serialze()
+    get transform(): Matrix4 {
+        return this.getPrivateValue("transform", Matrix4.identity());
+    }
+    set transform(value: Matrix4) {
+        this.setProperty("transform", value, undefined, {
+            equals: (left, right) => left.equals(right),
+        });
+    }
+
+    worldTransform(): Matrix4 {
+        const visual = this.document.visual.context.getVisual(this);
+        if (visual) {
+            return visual.worldTransform();
+        }
+        return this.transform;
+    }
+
+    protected onVisibleChanged(): void {
+        this.document.visual.context.setVisible(this, this.visible && this.parentVisible);
+    }
+
+    protected onParentVisibleChanged(): void {
+        this.document.visual.context.setVisible(this, this.visible && this.parentVisible);
+    }
+
+    abstract boundingBox(): BoundingBox | undefined;
+}

package/packages/chili-core/src/modelManager.ts

@@ -0,0 +1,147 @@
+// 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 {
+    CollectionAction,
+    type CollectionChangedArgs,
+    NodeLinkedListHistoryRecord,
+    type NodeRecord,
+    Observable,
+    ObservableCollection,
+    Transaction,
+} from "./foundation";
+import type { Material } from "./material";
+import type { Component } from "./model/component";
+import { FolderNode } from "./model/folderNode";
+import { type INode, type INodeLinkedList, NodeSerializer, NodeUtils } from "./model/node";
+import { type Serialized, Serializer } from "./serialize";
+
+export type OnNodeChanged = (records: NodeRecord[]) => void;
+
+export class ModelManager extends Observable {
+    private readonly _nodeChangedObservers = new Set<OnNodeChanged>();
+
+    readonly components: Component[] = [];
+    readonly materials: ObservableCollection<Material> = new ObservableCollection();
+
+    private _rootNode: INodeLinkedList | undefined;
+    get rootNode(): INodeLinkedList {
+        if (this._rootNode === undefined) {
+            this._rootNode = this.initRootNode();
+        }
+        return this._rootNode;
+    }
+    set rootNode(value: INodeLinkedList) {
+        if (this._rootNode === value) return;
+
+        this._rootNode?.removePropertyChanged(this.handleRootNodeNameChanged);
+        this._rootNode = value ?? new FolderNode(this.document, this.document.name);
+        this._rootNode.onPropertyChanged(this.handleRootNodeNameChanged);
+    }
+
+    private _currentNode?: INodeLinkedList;
+    get currentNode(): INodeLinkedList | undefined {
+        return this._currentNode;
+    }
+    set currentNode(value: INodeLinkedList | undefined) {
+        this.setProperty("currentNode", value);
+    }
+
+    constructor(readonly document: IDocument) {
+        super();
+        this.materials.onCollectionChanged(this.handleMaterialChanged);
+    }
+
+    private readonly handleRootNodeNameChanged = (prop: string) => {
+        if (prop === "name") {
+            this.document.name = this.rootNode.name;
+        }
+    };
+
+    initRootNode() {
+        return new FolderNode(this.document, this.document.name);
+    }
+
+    addNodeObserver(observer: OnNodeChanged) {
+        this._nodeChangedObservers.add(observer);
+    }
+
+    removeNodeObserver(observer: OnNodeChanged) {
+        this._nodeChangedObservers.delete(observer);
+    }
+
+    notifyNodeChanged(records: NodeRecord[]) {
+        Transaction.add(this.document, new NodeLinkedListHistoryRecord(records));
+        this._nodeChangedObservers.forEach((x) => {
+            x(records);
+        });
+    }
+
+    addNode(...nodes: INode[]): void {
+        (this.currentNode ?? this.rootNode).add(...nodes);
+    }
+
+    findNode(predicate: (value: INode) => boolean) {
+        if (!this._rootNode) return undefined;
+
+        return NodeUtils.findNode(this._rootNode, predicate);
+    }
+
+    findNodes(predicate?: (value: INode) => boolean) {
+        if (!this._rootNode) return [];
+
+        return NodeUtils.findNodes(this._rootNode, predicate);
+    }
+
+    serialize() {
+        return {
+            components: this.components.map((x) => Serializer.serializeObject(x)),
+            nodes: NodeSerializer.serialize(this.rootNode),
+            materials: this.materials.map((x) => Serializer.serializeObject(x)),
+        };
+    }
+
+    async deserialize(data: { components: Serialized[]; nodes: Serialized[]; materials: Serialized[] }) {
+        this.components.push(
+            ...data.components.map((x: Serialized) => Serializer.deserializeObject(this.document, x)),
+        );
+
+        this.materials.push(
+            ...data.materials.map((x: Serialized) => Serializer.deserializeObject(this.document, x)),
+        );
+
+        const rootNode = await NodeSerializer.deserialize(this.document, data.nodes);
+        this.rootNode = rootNode!;
+    }
+
+    override disposeInternal(): void {
+        super.disposeInternal();
+        this._nodeChangedObservers.clear();
+        this.materials.removeCollectionChanged(this.handleMaterialChanged);
+        this._rootNode?.removePropertyChanged(this.handleRootNodeNameChanged);
+        this._rootNode?.dispose();
+        this.materials.forEach((x) => x.dispose());
+        this.materials.clear();
+        this._rootNode = undefined;
+        this._currentNode = undefined;
+    }
+
+    private readonly handleMaterialChanged = (args: CollectionChangedArgs) => {
+        if (args.action === CollectionAction.add) {
+            Transaction.add(this.document, {
+                name: "MaterialChanged",
+                dispose() {},
+                undo: () => this.materials.remove(...args.items),
+                redo: () => this.materials.push(...args.items),
+            });
+        } else if (args.action === CollectionAction.remove) {
+            Transaction.add(this.document, {
+                name: "MaterialChanged",
+                dispose() {},
+                undo: () => this.materials.push(...args.items),
+                redo: () => this.materials.remove(...args.items),
+            });
+        }
+    };
+}

package/packages/chili-core/src/navigation.ts

@@ -0,0 +1,58 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Config } from "./config";
+
+export namespace Navigation3D {
+    export enum Nav3DType {
+        Chili3d = 0,
+        Revit,
+        Blender,
+        Creo,
+        Solidworks,
+    }
+    export const types: string[] = [Nav3DType[0], Nav3DType[1], Nav3DType[2], Nav3DType[3], Nav3DType[4]];
+
+    export function getKey(event: MouseEvent) {
+        let key = "Middle";
+        if (event.shiftKey) {
+            key = "Shift+" + key;
+        }
+        if (event.ctrlKey) {
+            key = "Ctrl+" + key;
+        }
+        if (event.altKey) {
+            key = "Alt+" + key;
+        }
+        return key;
+    }
+
+    export function navigationKeyMap(): {
+        pan: string;
+        rotate: string;
+    } {
+        const functionKey = {
+            [Nav3DType.Chili3d]: {
+                pan: "Middle",
+                rotate: "Shift+Middle",
+            },
+            [Nav3DType.Revit]: {
+                pan: "Middle",
+                rotate: "Shift+Middle",
+            },
+            [Nav3DType.Blender]: {
+                pan: "Shift+Middle",
+                rotate: "Middle",
+            },
+            [Nav3DType.Creo]: {
+                pan: "Shift+Middle",
+                rotate: "Middle",
+            },
+            [Nav3DType.Solidworks]: {
+                pan: "Ctrl+Middle",
+                rotate: "Middle",
+            },
+        };
+        return functionKey[Config.instance.navigation3DIndex as Nav3DType];
+    }
+}

package/packages/chili-core/src/property.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 { IConverter } from "./foundation";
+import type { I18nKeys } from "./i18n";
+
+export type PropertyType = "color" | "materialId";
+
+export interface Property {
+    name: string;
+    display: I18nKeys;
+    converter?: IConverter;
+    group?: I18nKeys;
+    icon?: string;
+    type?: PropertyType;
+    dependencies?: {
+        property: string | number | symbol;
+        value: any;
+    }[];
+}
+
+const PropertyKeyMap = new Map<Object, Map<string | number | symbol, Property>>();
+
+export namespace Property {
+    export function define(display: I18nKeys, parameters?: Omit<Property, "name" | "display">) {
+        return (target: Object, name: string) => {
+            if (!PropertyKeyMap.has(target)) {
+                PropertyKeyMap.set(target, new Map());
+            }
+            PropertyKeyMap.get(target)?.set(name, { display, name, ...parameters });
+        };
+    }
+
+    export function getProperties(target: any, until?: object): Property[] {
+        const result: Property[] = [];
+        getAllKeysOfPrototypeChain(target, result, until);
+        return result;
+    }
+
+    export function getOwnProperties(target: any): Property[] {
+        const properties = PropertyKeyMap.get(target);
+        if (!properties) return [];
+        return [...properties.values()];
+    }
+
+    function getAllKeysOfPrototypeChain(target: any, properties: Property[], until?: object) {
+        if (!target || target === until) return;
+        if (PropertyKeyMap.has(target)) {
+            properties.splice(0, 0, ...PropertyKeyMap.get(target)!.values());
+        }
+        getAllKeysOfPrototypeChain(Object.getPrototypeOf(target), properties, until);
+    }
+
+    export function getProperty<T extends Object>(target: T, property: keyof T): Property | undefined {
+        if (!target) return undefined;
+        const map = PropertyKeyMap.get(target);
+        if (map?.has(property)) return map.get(property);
+        return getProperty(Object.getPrototypeOf(target), property);
+    }
+}

package/packages/chili-core/src/selection.ts

@@ -0,0 +1,33 @@
+// 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, IDisposable } from "./foundation";
+import type { I18nKeys } from "./i18n";
+import type { INode, VisualNode } from "./model";
+import type { INodeFilter, IShapeFilter } from "./selectionFilter";
+import type { ShapeType } from "./shape";
+import type { CursorType, IEventHandler, VisualShapeData, VisualState } from "./visual";
+
+export interface ISelection extends IDisposable {
+    pickShape(
+        prompt: I18nKeys,
+        controller: AsyncController,
+        multiMode: boolean,
+        selectedState?: VisualState,
+        highlightState?: VisualState,
+    ): Promise<VisualShapeData[]>;
+    pickNode(prompt: I18nKeys, controller: AsyncController, multiMode: boolean): Promise<VisualNode[]>;
+    pickAsync(
+        handler: IEventHandler,
+        prompt: I18nKeys,
+        controller: AsyncController,
+        showControl: boolean,
+        cursor: CursorType,
+    ): Promise<void>;
+    shapeType: ShapeType;
+    shapeFilter?: IShapeFilter;
+    nodeFilter?: INodeFilter;
+    setSelection(nodes: INode[], toggle: boolean): number;
+    clearSelection(): void;
+    getSelectedNodes(): INode[];
+}

package/packages/chili-core/src/selectionFilter.ts

@@ -0,0 +1,28 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { type INode, ShapeNode } from "./model";
+import type { IShape } from "./shape";
+
+export interface IShapeFilter {
+    allow(shape: IShape): boolean;
+}
+
+export interface INodeFilter {
+    allow(node: INode): boolean;
+}
+
+export class ShapeNodeFilter implements INodeFilter {
+    constructor(readonly shapeFilter?: IShapeFilter) {}
+
+    allow(node: INode): boolean {
+        if (node instanceof ShapeNode) {
+            if (this.shapeFilter && node.shape.isOk) {
+                return this.shapeFilter.allow(node.shape.value);
+            }
+            return true;
+        }
+
+        return false;
+    }
+}

package/packages/chili-core/src/serialize/index.ts

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