chili3d 0.6.1

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

@@ -0,0 +1,305 @@
+// Part of the Chili3d Project, under the AGPL-3.0 Licensettt.
+// 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, Matrix4, type XYZ } from "../math";
+import { Property } from "../property";
+import { Serializer } from "../serialize";
+import { type EdgeMeshData, type FaceMeshData, LineType, Mesh } from "../shape";
+import { MeshUtils } from "../visual/meshUtils";
+import { MeshNode } from "./meshNode";
+import type { INode } from "./node";
+import { ShapeNode } from "./shapeNode";
+import { VisualNode } from "./visualNode";
+
+export type ComponentMesh = {
+    faceMaterials: string[];
+    edge: EdgeMeshData;
+    face: FaceMeshData;
+    linesegments: Mesh;
+    surfaceMaterials: string[];
+    surface: Mesh;
+};
+
+export function createComponentMesh(size: ComponentSize): ComponentMesh {
+    return {
+        faceMaterials: [],
+        edge: {
+            lineType: LineType.Solid,
+            position: new Float32Array(size.edge * 3),
+            range: [],
+        },
+        face: {
+            index: new Uint32Array(size.faceIndex),
+            normal: new Float32Array(size.facePosition * 3),
+            position: new Float32Array(size.facePosition * 3),
+            uv: new Float32Array(size.facePosition * 2),
+            range: [],
+            groups: [],
+        },
+        linesegments: Mesh.createLineSegments(size.lineSegment),
+        surfaceMaterials: [],
+        surface: Mesh.createSurface(
+            size.meshPosition,
+            size.meshIndex > 0 ? size.meshIndex : size.meshPosition * 3,
+        ),
+    };
+}
+
+export type ComponentSize = {
+    facePosition: number;
+    faceIndex: number;
+    edge: number;
+    lineSegment: number;
+    meshPosition: number;
+    meshIndex: number;
+};
+
+export function createComponentSize(): ComponentSize {
+    return {
+        facePosition: 0,
+        faceIndex: 0,
+        edge: 0,
+        lineSegment: 0,
+        meshIndex: 0,
+        meshPosition: 0,
+    };
+}
+
+@Serializer.register(["name", "nodes", "origin", "id"])
+export class Component {
+    private readonly _nodes: ReadonlyArray<VisualNode>;
+    @Serializer.serialze()
+    get nodes(): ReadonlyArray<VisualNode> {
+        return this._nodes;
+    }
+
+    private readonly _name: string;
+    @Serializer.serialze()
+    get name(): string {
+        return this._name;
+    }
+
+    @Serializer.serialze()
+    readonly id: string;
+
+    private _origin: XYZ;
+    @Serializer.serialze()
+    get origin(): XYZ {
+        return this._origin;
+    }
+    set origin(value: XYZ) {
+        this._origin = value;
+    }
+
+    private _boundingBox?: BoundingBox;
+    get boundingBox(): BoundingBox | undefined {
+        this._boundingBox ??= this.computeBoundingBox();
+        return this._boundingBox;
+    }
+
+    private _mesh?: ComponentMesh;
+    get mesh(): ComponentMesh {
+        this._mesh ??= this.mergeMesh();
+        return this._mesh;
+    }
+
+    public instances: ComponentNode[] = [];
+
+    constructor(name: string, nodes: ReadonlyArray<VisualNode>, origin?: XYZ, id = Id.generate()) {
+        this._name = name;
+        this._nodes = nodes;
+        this.id = id;
+        this._origin = origin ?? BoundingBox.center(this.boundingBox);
+    }
+
+    toString(): string {
+        return this.name;
+    }
+
+    private mergeMesh() {
+        const size: ComponentSize = createComponentSize();
+        this.getSize(this._nodes, size);
+        const mesh = createComponentMesh(size);
+
+        const offset: ComponentSize = createComponentSize();
+        const faceMaterialPair: [number, number][] = [];
+        this.mergeNodesMesh(mesh, faceMaterialPair, this._nodes, Matrix4.identity(), offset);
+        mesh.face = MeshUtils.mergeFaceMesh(mesh.face, faceMaterialPair);
+
+        return mesh;
+    }
+
+    private getSize(nodes: Iterable<INode>, size: ComponentSize) {
+        for (const node of nodes) {
+            if (node instanceof ShapeNode && node.shape.isOk) {
+                const mesh = node.shape.value.mesh;
+                if (mesh.faces) {
+                    size.facePosition += mesh.faces.position.length / 3;
+                    size.faceIndex += mesh.faces.index.length;
+                }
+                if (mesh.edges) size.edge += mesh.edges.position.length / 3;
+            } else if (node instanceof MeshNode) {
+                size.meshPosition += node.mesh.position!.length / 3;
+                if (node.mesh.meshType === "surface") {
+                    size.meshIndex += node.mesh.index?.length ?? 0;
+                }
+            } else if (node instanceof ComponentNode) {
+                this.getSize(node.component.nodes, size);
+            }
+        }
+    }
+
+    private readonly mergeNodesMesh = (
+        visual: ComponentMesh,
+        faceMaterialPair: [number, number][],
+        nodes: Iterable<VisualNode>,
+        transform: Matrix4,
+        offset: ComponentSize,
+    ) => {
+        for (const node of nodes) {
+            const totleTransform = node.transform.multiply(transform);
+            if (node instanceof ShapeNode && node.shape.isOk) {
+                this.mergeShapeNode(visual, faceMaterialPair, node, totleTransform, offset);
+            } else if (node instanceof ComponentNode) {
+                this.mergeNodesMesh(visual, faceMaterialPair, node.component.nodes, totleTransform, offset);
+            } else if (node instanceof MeshNode) {
+                this.mergeMeshNode(visual, node, totleTransform, offset);
+            } else {
+                console.log(`****** to do merge MeshNode ******: ${Object.prototype.toString.call(node)}`);
+            }
+        }
+    };
+
+    private mergeShapeNode(
+        visual: ComponentMesh,
+        faceMaterialPair: [number, number][],
+        node: ShapeNode,
+        transform: Matrix4,
+        offset: ComponentSize,
+    ) {
+        const mesh = node.shape.value.mesh;
+        if (mesh.edges) {
+            MeshUtils.setEdgeMeshData(visual.edge, mesh.edges, transform, offset.edge);
+            offset.edge += mesh.edges.position.length / 3;
+        }
+        if (mesh.faces) {
+            this.mergeFaceMaterial(node, visual, faceMaterialPair);
+            MeshUtils.setFaceMeshData(visual.face, mesh.faces, transform, offset);
+            offset.facePosition += mesh.faces.position.length / 3;
+            offset.faceIndex += mesh.faces.index.length;
+        }
+    }
+
+    private mergeFaceMaterial(node: ShapeNode, visual: ComponentMesh, faceMaterialPair: [number, number][]) {
+        const materialIndexMap = this.mapOldNewMaterialIndex(node.materialId, visual.faceMaterials);
+
+        const map = new Map<number, number>(
+            node.faceMaterialPair.map((pair) => [pair.faceIndex, pair.materialIndex]),
+        );
+        node.mesh.faces?.range.forEach((range, i) => {
+            if (!map.has(i)) {
+                faceMaterialPair.push([i + visual.face.range.length, materialIndexMap.get(0)!]);
+            }
+        });
+        node.faceMaterialPair.forEach((pair) => {
+            faceMaterialPair.push([
+                pair.faceIndex + visual.face.range.length,
+                materialIndexMap.get(pair.materialIndex)!,
+            ]);
+        });
+    }
+
+    private mergeMeshNode(visual: ComponentMesh, node: MeshNode, transform: Matrix4, offset: ComponentSize) {
+        if (node.mesh.meshType === "surface") {
+            const materialONMap = this.mapOldNewMaterialIndex(node.materialId, visual.surfaceMaterials);
+            MeshUtils.setSurfaceMeshData(visual.surface, node.mesh, transform, offset, materialONMap);
+            offset.meshPosition += node.mesh.position!.length / 3;
+            if (node.mesh.index?.length) {
+                offset.meshIndex += node.mesh.index.length;
+            }
+        } else if (node.mesh.meshType === "linesegments") {
+            visual.linesegments.position?.set(
+                transform.ofPoints(node.mesh.position!),
+                offset.lineSegment * 3,
+            );
+            offset.lineSegment += node.mesh.position!.length / 3;
+        }
+    }
+
+    private mapOldNewMaterialIndex(materialId: string | string[], materialIds: string[]) {
+        const materialIndexMap = new Map<number, number>();
+        const materials = Array.isArray(materialId) ? materialId : [materialId];
+        for (let i = 0; i < materials.length; i++) {
+            const index = materialIds.indexOf(materials[i]);
+            if (index === -1) {
+                materialIds.push(materials[i]);
+                materialIndexMap.set(i, materialIds.length - 1);
+            } else {
+                materialIndexMap.set(i, index);
+            }
+        }
+
+        return materialIndexMap;
+    }
+
+    private computeBoundingBox() {
+        if (this._nodes.length === 0) {
+            return undefined;
+        }
+
+        let box = this._nodes[0].boundingBox();
+        for (let i = 1; i < this._nodes.length; i++) {
+            box = BoundingBox.combine(box, this._nodes[i].boundingBox());
+        }
+        return box;
+    }
+}
+
+@Serializer.register(["document", "name", "componentId", "insert", "id"])
+export class ComponentNode extends VisualNode {
+    override display(): I18nKeys {
+        return "body.group";
+    }
+
+    override boundingBox(): BoundingBox | undefined {
+        if (!this.component.boundingBox) {
+            return undefined;
+        }
+
+        return BoundingBox.transformed(this.component.boundingBox, this.transform);
+    }
+
+    private _component?: Component;
+    @Property.define("body.group")
+    get component() {
+        if (!this._component) {
+            this._component = this.document.modelManager.components.find((c) => c.id === this.componentId);
+            if (!this._component) {
+                throw new Error(`Component ${this.componentId} not found`);
+            }
+            this._component.instances.push(this);
+        }
+        return this._component;
+    }
+
+    @Serializer.serialze()
+    readonly componentId: string;
+
+    @Serializer.serialze()
+    readonly insert: XYZ;
+
+    constructor(
+        document: IDocument,
+        name: string,
+        componentId: string,
+        insert: XYZ,
+        id: string = Id.generate(),
+    ) {
+        super(document, name, id);
+        this.componentId = componentId;
+        this.insert = insert;
+    }
+}

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

@@ -0,0 +1,17 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Property } from "../property";
+import { Serializer } from "../serialize";
+import { ParameterShapeNode } from "./shapeNode";
+
+export abstract class FacebaseNode extends ParameterShapeNode {
+    @Serializer.serialze()
+    @Property.define("option.command.isFace")
+    get isFace() {
+        return this.getPrivateValue("isFace", false);
+    }
+    set isFace(value: boolean) {
+        this.setProperty("isFace", value);
+    }
+}

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

@@ -0,0 +1,289 @@
+// 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, Logger, NodeAction } from "../foundation";
+import { Serializer } from "../serialize";
+import { type INode, type INodeLinkedList, Node } from "./node";
+
+@Serializer.register(["document", "name", "id"])
+export class FolderNode extends Node implements INodeLinkedList {
+    private _count: number = 0;
+    private _firstChild: INode | undefined;
+    private _lastChild: INode | undefined;
+
+    get firstChild() {
+        return this._firstChild;
+    }
+    get lastChild() {
+        return this._lastChild;
+    }
+    get count() {
+        return this._count;
+    }
+    size(): number {
+        return this._count;
+    }
+
+    constructor(document: IDocument, name: string, id: string = Id.generate()) {
+        super(document, name, id);
+    }
+
+    add(...items: INode[]): void {
+        const records = items.map((item) => ({
+            action: NodeAction.add,
+            node: item,
+            oldParent: undefined,
+            oldPrevious: undefined,
+            newParent: this,
+            newPrevious: this._lastChild,
+        }));
+
+        items.forEach((item) => {
+            if (this.initNode(item)) {
+                this.addToLast(item);
+            }
+            this._count++;
+        });
+
+        this.document.modelManager.notifyNodeChanged(records);
+    }
+
+    private initNode(node: INode): boolean {
+        node.parent = this;
+        node.parentVisible = this.visible && this.parentVisible;
+        if (!this._firstChild) {
+            this._firstChild = this._lastChild = node;
+            node.previousSibling = node.nextSibling = undefined;
+            return false;
+        }
+        return true;
+    }
+
+    private addToLast(item: INode) {
+        this._lastChild!.nextSibling = item;
+        item.previousSibling = this._lastChild;
+        item.nextSibling = undefined;
+        this._lastChild = item;
+    }
+
+    children(): INode[] {
+        const result: INode[] = [];
+        let node = this._firstChild;
+        while (node) {
+            result.push(node);
+            node = node.nextSibling;
+        }
+        return result;
+    }
+
+    remove(...items: INode[]): void {
+        const records = items
+            .filter((item) => this.validateChild(item))
+            .map((item) => ({
+                action: NodeAction.remove,
+                node: item,
+                newParent: undefined,
+                newPrevious: undefined,
+                oldParent: this,
+                oldPrevious: item.previousSibling,
+            }));
+
+        records.forEach((record) => this.removeNode(record.node, true));
+        this.document.modelManager.notifyNodeChanged(records);
+    }
+
+    transfer(...items: INode[]): void {
+        const records = items
+            .filter((item) => this.validateChild(item))
+            .map((item) => ({
+                action: NodeAction.transfer,
+                node: item,
+                newParent: undefined,
+                newPrevious: undefined,
+                oldParent: this,
+                oldPrevious: item.previousSibling,
+            }));
+
+        records.forEach((record) => this.removeNode(record.node, true));
+        this.document.modelManager.notifyNodeChanged(records);
+    }
+
+    private validateChild(item: INode): boolean {
+        if (item.parent !== this) {
+            Logger.warn(`${item.name} is not a child node of the ${this.name} node`);
+            return false;
+        }
+        return true;
+    }
+
+    private removeNode(node: INode, nullifyParent: boolean) {
+        if (nullifyParent) {
+            node.parent = undefined;
+            node.parentVisible = true;
+        }
+
+        if (node === this._firstChild) {
+            this.removeFirstNode(node);
+        } else if (node === this._lastChild) {
+            this.removeLastNode(node);
+        } else {
+            this.removeMiddleNode(node);
+        }
+        this._count--;
+    }
+
+    private removeFirstNode(node: INode) {
+        if (node === this._lastChild) {
+            this._firstChild = this._lastChild = undefined;
+        } else {
+            this._firstChild = node.nextSibling;
+            this._firstChild!.previousSibling = undefined;
+            node.nextSibling = undefined;
+        }
+    }
+
+    private removeLastNode(node: INode) {
+        this._lastChild = node.previousSibling;
+        this._lastChild!.nextSibling = undefined;
+        node.previousSibling = undefined;
+    }
+
+    private removeMiddleNode(node: INode) {
+        node.previousSibling!.nextSibling = node.nextSibling;
+        node.nextSibling!.previousSibling = node.previousSibling;
+        node.previousSibling = node.nextSibling = undefined;
+    }
+
+    insertBefore(target: INode | undefined, node: INode): void {
+        if (target && !this.validateChild(target)) return;
+
+        const record = {
+            action: NodeAction.insertBefore,
+            node,
+            oldParent: undefined,
+            oldPrevious: undefined,
+            newParent: this,
+            newPrevious: target?.previousSibling,
+        };
+
+        if (this.initNode(node)) {
+            if (!target || target === this._firstChild) {
+                this.insertAsFirst(node);
+            } else {
+                this.insertBetweenNodes(target.previousSibling!, node, target);
+            }
+        }
+        this._count++;
+        this.document.modelManager.notifyNodeChanged([record]);
+    }
+
+    private insertAsFirst(node: INode) {
+        this._firstChild!.previousSibling = node;
+        node.nextSibling = this._firstChild;
+        this._firstChild = node;
+    }
+
+    private insertBetweenNodes(prev: INode, node: INode, next: INode) {
+        prev.nextSibling = node;
+        node.previousSibling = prev;
+        node.nextSibling = next;
+        next.previousSibling = node;
+    }
+
+    insertAfter(target: INode | undefined, node: INode): void {
+        if (target && !this.validateChild(target)) return;
+
+        const record = {
+            action: NodeAction.insertAfter,
+            oldParent: undefined,
+            oldPrevious: undefined,
+            newParent: this,
+            newPrevious: target,
+            node,
+        };
+
+        if (this.initNode(node)) {
+            if (!target) {
+                this.insertAsFirst(node);
+            } else if (target === this._lastChild) {
+                this.addToLast(node);
+            } else {
+                this.insertBetweenNodes(target, node, target.nextSibling!);
+            }
+        }
+        this._count++;
+        this.document.modelManager.notifyNodeChanged([record]);
+    }
+
+    move(child: INode, newParent: FolderNode, previousSibling?: INode): void {
+        if (previousSibling && previousSibling.parent !== newParent) {
+            Logger.warn(`${previousSibling.name} is not a child node of the ${newParent.name} node`);
+            return;
+        }
+
+        const record = {
+            action: NodeAction.move,
+            oldParent: child.parent,
+            oldPrevious: child.previousSibling,
+            newParent: newParent,
+            newPrevious: previousSibling,
+            node: child,
+        };
+
+        this.removeNode(child, false);
+
+        if (newParent.initNode(child)) {
+            if (!previousSibling) {
+                newParent.insertAsFirst(child);
+            } else if (previousSibling === newParent._lastChild) {
+                newParent.addToLast(child);
+            } else {
+                newParent.insertBetweenNodes(previousSibling, child, previousSibling.nextSibling!);
+            }
+        }
+        newParent._count++;
+
+        this.document.modelManager.notifyNodeChanged([record]);
+    }
+
+    override disposeInternal(): void {
+        this.disposeNodes(this._firstChild);
+        super.disposeInternal();
+    }
+
+    private readonly disposeNodes = (node: INode | undefined) => {
+        if (node instanceof FolderNode) {
+            this.disposeNodes(node.firstChild);
+        }
+
+        let next = node?.nextSibling;
+        if (node) {
+            node.nextSibling = null as any;
+        }
+        while (next) {
+            const cache = next.nextSibling;
+            next.previousSibling = null as any;
+            next.nextSibling = null as any;
+            next.dispose();
+            next = cache;
+        }
+        node?.dispose();
+    };
+
+    protected onVisibleChanged() {
+        this.setChildrenParentVisible();
+    }
+
+    protected onParentVisibleChanged() {
+        this.setChildrenParentVisible();
+    }
+
+    private setChildrenParentVisible() {
+        let child = this._firstChild;
+        while (child !== undefined) {
+            child.parentVisible = this.visible && this.parentVisible;
+            child = child.nextSibling;
+        }
+    }
+}