chili3d 0.6.1

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

@@ -0,0 +1,185 @@
+// 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 { Id, PropertyHistoryRecord, Transaction } from "../foundation";
+import { BoundingBox } from "../math";
+import { Property } from "../property";
+import { Serializer } from "../serialize";
+import type { FaceMeshData, IShapeMeshData } from "../shape";
+import { MeshUtils } from "../visual/meshUtils";
+import { VisualNode } from "./visualNode";
+
+@Serializer.register(["faceIndex", "materialIndex"])
+export class FaceMaterialPair {
+    @Serializer.serialze()
+    faceIndex: number;
+
+    @Serializer.serialze()
+    materialIndex: number;
+    constructor(faceIndex: number, materialIndex: number) {
+        this.faceIndex = faceIndex;
+        this.materialIndex = materialIndex;
+    }
+}
+
+export abstract class GeometryNode extends VisualNode {
+    @Serializer.serialze()
+    @Property.define("common.material", { type: "materialId" })
+    get materialId(): string | string[] {
+        return this.getPrivateValue("materialId");
+    }
+    set materialId(value: string | string[]) {
+        this.setProperty("materialId", value);
+    }
+
+    protected _originFaceMesh?: FaceMeshData;
+
+    @Serializer.serialze()
+    get faceMaterialPair(): FaceMaterialPair[] {
+        return this.getPrivateValue("faceMaterialPair", []);
+    }
+    set faceMaterialPair(value: FaceMaterialPair[]) {
+        const oldMaterisl = Array.isArray(this.materialId) ? [...this.materialId] : this.materialId;
+        const Face = [...this.faceMaterialPair];
+        this.setProperty("faceMaterialPair", value, () => this.updateVisual(oldMaterisl, Face));
+    }
+
+    constructor(
+        document: IDocument,
+        name: string,
+        materialId?: string | string[],
+        id: string = Id.generate(),
+    ) {
+        super(document, name, id);
+        this.setPrivateValue("materialId", materialId ?? document.modelManager.materials.at(0)?.id ?? "");
+    }
+
+    protected _mesh: IShapeMeshData | undefined;
+    get mesh(): IShapeMeshData {
+        this._mesh ??= this.createMesh();
+        return this._mesh as any;
+    }
+
+    override boundingBox(): BoundingBox | undefined {
+        let points = this.mesh.faces?.position;
+        if (!points || points.length === 0) {
+            points = this.mesh.edges?.position;
+        }
+
+        if (!points || points.length === 0) {
+            return undefined;
+        }
+        return BoundingBox.fromNumbers(this.transform.ofPoints(points));
+    }
+
+    override disposeInternal(): void {
+        super.disposeInternal();
+        this._mesh = undefined;
+    }
+
+    private copyOldValue() {
+        const oldMaterial = Array.isArray(this.materialId) ? [...this.materialId] : this.materialId;
+        const oldFacePair = [...this.faceMaterialPair];
+        return {
+            oldFacePair,
+            oldMaterial,
+        };
+    }
+
+    addFaceMaterial(pairs: { faceIndex: number; materialId: string }[]) {
+        const { oldFacePair, oldMaterial } = this.copyOldValue();
+        pairs.forEach(({ faceIndex, materialId }) => {
+            if (this.materialId === materialId) {
+                return;
+            }
+
+            if (this._mesh?.faces?.range.length === 1) {
+                this.setPrivateValue("materialId", materialId);
+                return;
+            }
+
+            if (typeof this.materialId === "string") {
+                this.setPrivateValue("materialId", [this.materialId, materialId]);
+            }
+
+            const index = this.materialId.indexOf(materialId);
+            if (index === -1) {
+                (this.materialId as string[]).push(materialId);
+                this.faceMaterialPair.push(new FaceMaterialPair(faceIndex, this.materialId.length - 1));
+            } else {
+                this.faceMaterialPair.push(new FaceMaterialPair(faceIndex, index));
+            }
+        });
+        this.updateVisual(oldMaterial, oldFacePair);
+    }
+
+    removeFaceMaterial(faceIndexs: number[]) {
+        const { oldFacePair, oldMaterial } = this.copyOldValue();
+        const toDelete = this.faceMaterialPair.filter((x) => faceIndexs.includes(x.faceIndex));
+        this.setPrivateValue(
+            "faceMaterialPair",
+            this.faceMaterialPair.filter((x) => !faceIndexs.includes(x.faceIndex)),
+        );
+        toDelete.forEach((pair) => {
+            const hasSameMaterial = this.faceMaterialPair.some((x) => x.materialIndex === pair.materialIndex);
+            if (hasSameMaterial || !Array.isArray(this.materialId)) {
+                return;
+            }
+            this.materialId.splice(pair.materialIndex, 1);
+            if (this.materialId.length === 1) {
+                this.setPrivateValue("materialId", this.materialId[0]);
+            } else if (this.materialId.length > 1) {
+                this.faceMaterialPair.forEach((x) => {
+                    if (x.materialIndex > pair.materialIndex) {
+                        x.materialIndex--;
+                    }
+                });
+            }
+        });
+
+        this.updateVisual(oldMaterial, oldFacePair);
+    }
+
+    clearFaceMaterial() {
+        const { oldFacePair, oldMaterial } = this.copyOldValue();
+
+        if (Array.isArray(this.materialId)) {
+            this.setPrivateValue("materialId", this.materialId[0]);
+        }
+        this.setPrivateValue("faceMaterialPair", []);
+
+        this.updateVisual(oldMaterial, oldFacePair);
+    }
+
+    private readonly updateVisual = (oldMaterisl: string | string[], oldFacePair: FaceMaterialPair[]) => {
+        if (!this._originFaceMesh) return;
+        if (this.faceMaterialPair.length === 0) {
+            this._mesh!.faces = this._originFaceMesh;
+        } else {
+            this._mesh!.faces = MeshUtils.mergeFaceMesh(
+                this._originFaceMesh,
+                this.faceMaterialPair.map((x) => [x.faceIndex, x.materialIndex] as [number, number]),
+            );
+            if (this._mesh!.faces.groups.length === 1) {
+                this.setPrivateValue("materialId", this.materialId[this.faceMaterialPair[0].materialIndex]);
+            }
+        }
+
+        this.emitPropertyChanged("materialId", oldMaterisl);
+        this.emitPropertyChanged("faceMaterialPair", oldFacePair);
+        const newMaterisl = Array.isArray(this.materialId) ? [...this.materialId] : this.materialId;
+        Transaction.add(
+            this.document,
+            new PropertyHistoryRecord(this, "materialId", oldMaterisl, newMaterisl),
+        );
+        Transaction.add(
+            this.document,
+            new PropertyHistoryRecord(this, "faceMaterialPair", oldFacePair, [...this.faceMaterialPair]),
+        );
+
+        this.document.visual.context.redrawNode([this]);
+    };
+
+    protected abstract createMesh(): IShapeMeshData;
+}

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

@@ -0,0 +1,19 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Matrix4 } from "../math";
+import { Serializer } from "../serialize";
+import { FolderNode } from "./folderNode";
+
+@Serializer.register(["document", "name", "id"])
+export class GroupNode extends FolderNode {
+    @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),
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./component";
+export * from "./facebaseNode";
+export * from "./folderNode";
+export * from "./geometryNode";
+export * from "./groupNode";
+export * from "./meshNode";
+export * from "./node";
+export * from "./shapeNode";
+export * from "./visualNode";

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

@@ -0,0 +1,53 @@
+// 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 { Id } from "../foundation";
+import type { I18nKeys } from "../i18n";
+import { BoundingBox } from "../math";
+import { Property } from "../property";
+import { Serializer } from "../serialize";
+import type { Mesh } from "../shape";
+import { VisualNode } from "./visualNode";
+
+@Serializer.register(["document", "mesh", "name", "id"])
+export class MeshNode extends VisualNode {
+    override display(): I18nKeys {
+        return "body.meshNode";
+    }
+
+    @Serializer.serialze()
+    @Property.define("common.material", { type: "materialId" })
+    get materialId(): string | string[] {
+        return this.getPrivateValue("materialId");
+    }
+    set materialId(value: string | string[]) {
+        this.setProperty("materialId", value);
+    }
+
+    protected _mesh: Mesh;
+    @Serializer.serialze()
+    get mesh(): Mesh {
+        return this._mesh;
+    }
+    set mesh(value: Mesh) {
+        this.setProperty("mesh", value);
+    }
+
+    constructor(
+        document: IDocument,
+        mesh: Mesh,
+        name: string,
+        materialId?: string | string[],
+        id: string = Id.generate(),
+    ) {
+        super(document, name, id);
+        this._mesh = mesh;
+        this.setPrivateValue("materialId", materialId ?? document.modelManager.materials.at(0)?.id ?? "");
+    }
+
+    override boundingBox(): BoundingBox | undefined {
+        const points = this.transform.ofPoints(this.mesh.position!);
+        return BoundingBox.fromNumbers(points);
+    }
+}

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

@@ -0,0 +1,315 @@
+// 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 { HistoryObservable, type IDisposable, Id, type IPropertyChanged } from "../foundation";
+import { Property } from "../property";
+import { type Serialized, Serializer } from "../serialize";
+
+export interface INode extends IPropertyChanged, IDisposable {
+    readonly id: string;
+    visible: boolean;
+    parentVisible: boolean;
+    name: string;
+    parent: INodeLinkedList | undefined;
+    previousSibling: INode | undefined;
+    nextSibling: INode | undefined;
+    clone(): this;
+}
+
+export interface INodeLinkedList extends INode {
+    get firstChild(): INode | undefined;
+    get lastChild(): INode | undefined;
+    add(...items: INode[]): void;
+    remove(...items: INode[]): void;
+    transfer(...items: INode[]): void;
+    size(): number;
+    insertAfter(target: INode | undefined, node: INode): void;
+    insertBefore(target: INode | undefined, node: INode): void;
+    move(child: INode, newParent: this, newPreviousSibling?: INode): void;
+}
+
+export namespace INode {
+    export function isLinkedListNode(node: INode): node is INodeLinkedList {
+        return (node as INodeLinkedList).add !== undefined;
+    }
+}
+
+export abstract class Node extends HistoryObservable implements INode {
+    parent: INodeLinkedList | undefined;
+    previousSibling: INode | undefined;
+    nextSibling: INode | undefined;
+
+    @Serializer.serialze()
+    readonly id: string;
+
+    constructor(document: IDocument, name: string, id: string) {
+        super(document);
+        this.id = id;
+        this.setPrivateValue("name", name || "untitled");
+    }
+
+    @Serializer.serialze()
+    @Property.define("common.name")
+    get name() {
+        return this.getPrivateValue("name");
+    }
+    set name(value: string) {
+        this.setProperty("name", value);
+    }
+
+    @Serializer.serialze()
+    get visible(): boolean {
+        return this.getPrivateValue("visible", true);
+    }
+    set visible(value: boolean) {
+        this.setProperty("visible", value, () => this.onVisibleChanged());
+    }
+
+    protected abstract onVisibleChanged(): void;
+
+    get parentVisible() {
+        return this.getPrivateValue("parentVisible", true);
+    }
+    set parentVisible(value: boolean) {
+        this.setProperty("parentVisible", value, () => this.onParentVisibleChanged());
+    }
+
+    override disposeInternal(): void {
+        this.document.visual.context.removeNode([this]);
+        super.disposeInternal();
+    }
+
+    clone(): this {
+        const oldValue = this.document.history.disabled;
+        try {
+            this.document.history.disabled = true;
+            const serialized = Serializer.serializeObject(this);
+            serialized.properties["id"] = Id.generate();
+            serialized.properties["name"] = `${this.name}_copy`;
+            return Serializer.deserializeObject(this.document, serialized) as this;
+        } finally {
+            this.document.history.disabled = oldValue;
+        }
+    }
+
+    protected abstract onParentVisibleChanged(): void;
+}
+
+export namespace INode {
+    export function getNodesBetween(node1: INode, node2: INode): INode[] {
+        if (node1 === node2) return [node1];
+        const nodes: INode[] = [];
+        const prePath = getPathToRoot(node1);
+        const curPath = getPathToRoot(node2);
+        const index = getCommonParentIndex(prePath, curPath);
+        const parent = prePath.at(1 - index) as INodeLinkedList;
+        if (parent === curPath[0] || parent === prePath[0]) {
+            const child = parent === curPath[0] ? prePath[0] : curPath[0];
+            getNodesFromParentToChild(nodes, parent, child);
+        } else if (currentAtBack(prePath.at(-index)!, curPath.at(-index)!)) {
+            getNodesFromPath(nodes, prePath, curPath, index);
+        } else {
+            getNodesFromPath(nodes, curPath, prePath, index);
+        }
+        return nodes;
+    }
+
+    function getNodesFromPath(nodes: INode[], path1: INode[], path2: INode[], commonIndex: number) {
+        nodeOrChildrenAppendToNodes(nodes, path1[0]);
+        path1ToCommonNodes(nodes, path1, commonIndex);
+        commonToPath2Nodes(nodes, path1, path2, commonIndex);
+    }
+
+    function path1ToCommonNodes(nodes: INode[], path1: INode[], commonIndex: number) {
+        for (let i = 0; i < path1.length - commonIndex; i++) {
+            let next = path1[i].nextSibling;
+            while (next !== undefined) {
+                INode.nodeOrChildrenAppendToNodes(nodes, next);
+                next = next.nextSibling;
+            }
+        }
+    }
+
+    function commonToPath2Nodes(nodes: INode[], path1: INode[], path2: INode[], commonIndex: number) {
+        let nextParent = path1.at(-commonIndex)?.nextSibling;
+        while (nextParent) {
+            if (nextParent === path2[0]) {
+                nodes.push(path2[0]);
+                return;
+            }
+            if (INode.isLinkedListNode(nextParent)) {
+                if (getNodesFromParentToChild(nodes, nextParent, path2[0])) {
+                    return;
+                }
+            } else {
+                nodes.push(nextParent);
+            }
+            nextParent = nextParent.nextSibling;
+        }
+    }
+
+    export function nodeOrChildrenAppendToNodes(nodes: INode[], node: INode) {
+        if (INode.isLinkedListNode(node)) {
+            getNodesFromParentToChild(nodes, node);
+        } else {
+            nodes.push(node);
+        }
+    }
+
+    export function findTopLevelNodes(nodes: Set<INode>) {
+        const result: INode[] = [];
+        for (const node of nodes) {
+            if (!containsDescendant(nodes, node)) {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+
+    export function containsDescendant(nodes: Set<INode>, node: INode): boolean {
+        if (node.parent === undefined) return false;
+        if (nodes.has(node.parent)) return true;
+        return containsDescendant(nodes, node.parent);
+    }
+
+    function getNodesFromParentToChild(nodes: INode[], parent: INodeLinkedList, until?: INode): boolean {
+        nodes.push(parent);
+        let node = parent.firstChild;
+        while (node !== undefined) {
+            if (until === node) {
+                nodes.push(node);
+                return true;
+            }
+
+            if (INode.isLinkedListNode(node)) {
+                if (getNodesFromParentToChild(nodes, node, until)) return true;
+            } else {
+                nodes.push(node);
+            }
+            node = node.nextSibling;
+        }
+        return false;
+    }
+
+    function currentAtBack(preNode: INode, curNode: INode) {
+        while (preNode.nextSibling !== undefined) {
+            if (preNode.nextSibling === curNode) return true;
+            preNode = preNode.nextSibling;
+        }
+        return false;
+    }
+
+    function getCommonParentIndex(prePath: INode[], curPath: INode[]) {
+        let index = 1;
+        for (index; index <= Math.min(prePath.length, curPath.length); index++) {
+            if (prePath.at(-index) !== curPath.at(-index)) break;
+        }
+        if (prePath.at(1 - index) !== curPath.at(1 - index)) throw new Error("can not find a common parent");
+        return index;
+    }
+
+    function getPathToRoot(node: INode): INode[] {
+        const path: INode[] = [];
+        let parent: INode | undefined = node;
+        while (parent !== undefined) {
+            path.push(parent);
+            parent = parent.parent;
+        }
+        return path;
+    }
+}
+
+export class NodeUtils {
+    static findNode(parent: INodeLinkedList, predicate: (value: INode) => boolean) {
+        function findNodeRecursive(
+            node: INode | undefined,
+            predicate: (value: INode) => boolean,
+        ): INode | undefined {
+            if (!node) {
+                return undefined;
+            }
+
+            if (predicate(node)) {
+                return node;
+            }
+
+            if (INode.isLinkedListNode(node)) {
+                const found = findNodeRecursive(node.firstChild, predicate);
+                if (found) {
+                    return found;
+                }
+            }
+
+            return findNodeRecursive(node.nextSibling, predicate);
+        }
+
+        return findNodeRecursive(parent.firstChild, predicate);
+    }
+
+    static findNodes(parent: INodeLinkedList, predicate?: (value: INode) => boolean) {
+        function findNodesRecursive(
+            result: INode[],
+            node: INode | undefined,
+            predicate?: (value: INode) => boolean,
+        ) {
+            if (!node) return;
+
+            if (!predicate || predicate(node)) {
+                result.push(node);
+            }
+
+            if (INode.isLinkedListNode(node)) {
+                findNodesRecursive(result, node.firstChild, predicate);
+            }
+
+            if (node.nextSibling) {
+                findNodesRecursive(result, node.nextSibling, predicate);
+            }
+        }
+
+        const result: INode[] = [];
+        findNodesRecursive(result, parent.firstChild, predicate);
+        return result;
+    }
+}
+
+export namespace NodeSerializer {
+    export function serialize(node: INode) {
+        const nodes: Serialized[] = [];
+        serializeNodeToArray(nodes, node, undefined);
+        return nodes;
+    }
+
+    function serializeNodeToArray(nodes: Serialized[], node: INode, parentId: string | undefined) {
+        const serialized: any = Serializer.serializeObject(node);
+        if (parentId) serialized["parentId"] = parentId;
+        nodes.push(serialized);
+
+        if (INode.isLinkedListNode(node) && node.firstChild) {
+            serializeNodeToArray(nodes, node.firstChild, node.id);
+        }
+        if (node.nextSibling) {
+            serializeNodeToArray(nodes, node.nextSibling, parentId);
+        }
+        return nodes;
+    }
+
+    export async function deserialize(document: IDocument, nodes: Serialized[]) {
+        const nodeMap: Map<string, INodeLinkedList> = new Map();
+        nodes.forEach((n) => {
+            const node = Serializer.deserializeObject(document, n);
+            if (INode.isLinkedListNode(node)) {
+                nodeMap.set(n.properties["id"], node);
+            }
+            const parentId = (n as any)["parentId"];
+            if (!parentId) return;
+            if (nodeMap.has(parentId)) {
+                nodeMap.get(parentId)!.add(node);
+            } else {
+                console.warn("parent not found: " + parentId);
+            }
+        });
+        return Promise.resolve(nodeMap.get(nodes[0].properties["id"]));
+    }
+}