@shapediver/viewer.shared.node-tree 2.3.4 → 2.4.0

package/src/implementation/{TreeNode.ts → AbstractTreeNode.ts}

@@ -5,33 +5,28 @@ import { Box, IBox } from '@shapediver/viewer.shared.math'
 
 import { ITransformation, ITreeNode } from '../interfaces/ITreeNode'
 import { ITreeNodeData } from '../interfaces/ITreeNodeData'
-import { ISDObject } from '../interfaces/ISDObject'
 
-export class TreeNode implements ITreeNode {
+export abstract class AbstractTreeNode<T extends ITreeNode<any, ITreeNodeData<any>>, U extends ITreeNodeData<any>> implements ITreeNode<T, U> {
   // #region Properties (13)
 
   readonly #uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
 
-  readonly #children: ITreeNode[] = [];
-  readonly #data: ITreeNodeData[] = [];
+  readonly #children: T[] = [];
+  readonly #data: U[] = [];
   #transformations: ITransformation[] = [];
 
   readonly #id: string;
-  readonly #name: string = '';
+  #name: string = '';
   #version: string;
-  #parent?: ITreeNode;
+  #parent?: T;
 
   readonly #boundingBox: IBox = new Box();
-  readonly #transformedNodes: {
-    [key: string]: ISDObject
-  } = {};
-
   #excludeViewports: string[] = [];
   #restrictViewports: string[] = [];
 
   #visible: boolean = true;
   #skinNode: boolean = false;
-  #bones: ITreeNode[] = [];
+  #bones: T[] = [];
   #boneInverses: mat4[] = [];
   #originalId: string;
 
@@ -49,8 +44,8 @@ export class TreeNode implements ITreeNode {
    */
   constructor(
     name: string = 'node',
-    parent?: ITreeNode,
-    data: ITreeNodeData[] = [],
+    parent?: T,
+    data: U[] = [],
     transformations: ITransformation[] = []
   ) {
     this.#name = name.replace(/\./g, "_");
@@ -69,11 +64,11 @@ export class TreeNode implements ITreeNode {
   // #region Public Accessors (19)
 
 
-  public get bones(): ITreeNode[] {
+  public get bones(): T[] {
     return this.#bones;
   }
 
-  public set bones(value: ITreeNode[]) {
+  public set bones(value: T[]) {
     this.#bones = value;
     this.updateVersion();
   }
@@ -91,7 +86,7 @@ export class TreeNode implements ITreeNode {
     return this.#boundingBox;
   }
 
-  public get children(): ITreeNode[] {
+  public get children(): T[] {
     return this.#children;
   }
 
@@ -103,7 +98,7 @@ export class TreeNode implements ITreeNode {
     this.#originalId = value;
   }
 
-  public get data(): ITreeNodeData[] {
+  public get data(): U[] {
     return this.#data;
   }
 
@@ -124,6 +119,10 @@ export class TreeNode implements ITreeNode {
     return this.#name;
   }
 
+  public set name(value: string) {
+    this.#name = value;
+  }
+
   public get nodeMatrix(): mat4 {
     const matrix: mat4 = mat4.create();
     for (let transform of this.#transformations)
@@ -131,11 +130,11 @@ export class TreeNode implements ITreeNode {
     return matrix;
   }
 
-  public get parent(): ITreeNode | undefined {
+  public get parent(): T | undefined {
     return this.#parent;
   }
 
-  public set parent(value: ITreeNode | undefined) {
+  public set parent(value: T | undefined) {
     // check if it was removed from previous parent
     if (this.#parent)
       this.#parent.removeChild(this);
@@ -173,12 +172,6 @@ export class TreeNode implements ITreeNode {
     this.#transformations = value;
   }
 
-  public get transformedNodes(): {
-    [key: string]: ISDObject
-  } {
-    return this.#transformedNodes;
-  }
-
   public get version(): string {
     return this.#version;
   }
@@ -202,7 +195,7 @@ export class TreeNode implements ITreeNode {
     for (let transform of this.#transformations)
       mat4.multiply(matrix, matrix, transform.matrix);
 
-    let node: ITreeNode = this;
+    let node: AbstractTreeNode<any, any> = this;
     while (node.parent) {
       mat4.multiply(matrix, node.parent.nodeMatrix, matrix);
       node = node.parent;
@@ -215,17 +208,17 @@ export class TreeNode implements ITreeNode {
 
   // #region Public Methods (16)
 
-  public addChild(child: ITreeNode): boolean {
+  public addChild(child: T): boolean {
     if (this.hasChild(child)) return false;
 
     this.#children.push(child);
     if (child.parent)
       child.parent.removeChild(child);
-    (<ITreeNode | undefined>child.parent) = this;
+    (<AbstractTreeNode<any, any>>child.parent) = this;
     return true;
   }
 
-  public addData(data: ITreeNodeData): boolean {
+  public addData(data: U): boolean {
     this.#data.push(data);
     return true;
   }
@@ -235,8 +228,9 @@ export class TreeNode implements ITreeNode {
     return true;
   }
 
-  public clone(): ITreeNode {
-    const clone = new TreeNode(this.name);
+  public clone(): T {
+    const clone = new (<any>this.constructor);
+    clone.name = this.name;
     clone.originalId = this.originalId;
     clone.visible = this.visible;
     for (let child of this.#children)
@@ -252,8 +246,9 @@ export class TreeNode implements ITreeNode {
     return clone;
   }
 
-  public cloneInstance(): ITreeNode {
-    const clone = new TreeNode(this.name);
+  public cloneInstance(): T {
+    const clone = new (<any>this.constructor);
+    clone.name = this.name;
     clone.originalId = this.originalId;
     clone.visible = this.visible;
     for (let child of this.#children)
@@ -269,14 +264,14 @@ export class TreeNode implements ITreeNode {
     return clone;
   }
 
-  public getChild(id: string): ITreeNode | undefined {
+  public getChild(id: string): T | undefined {
     for (let i = 0; i < this.#children.length; i++)
       if (this.#children[i].id === id)
         return this.#children[i];
     return;
   }
 
-  public getData(id: string): ITreeNodeData | undefined {
+  public getData(id: string): U | undefined {
     for (let i = 0; i < this.#data.length; i++)
       if (this.#data[i].id === id)
         return this.#data[i];
@@ -285,7 +280,7 @@ export class TreeNode implements ITreeNode {
 
   public getPath(): string {
     let path = this.name;
-    let node: ITreeNode | undefined = this.parent;
+    let node: T | undefined = this.parent;
     while (node) {
       path = node.name + '.' + path;
       node = node.parent;
@@ -300,11 +295,11 @@ export class TreeNode implements ITreeNode {
     return;
   }
 
-  public hasChild(child: ITreeNode): boolean {
+  public hasChild(child: T): boolean {
     return this.#children.includes(child);
   }
 
-  public hasData(data: ITreeNodeData): boolean {
+  public hasData(data: U): boolean {
     return this.#data.includes(data);
   }
 
@@ -312,15 +307,15 @@ export class TreeNode implements ITreeNode {
     return this.#transformations.includes(transformation);
   }
 
-  public removeChild(child: ITreeNode): boolean {
+  public removeChild(child: T): boolean {
     const index = this.#children.indexOf(child);
     if (index === -1) return false;
     this.#children.splice(index, 1);
-    (<ITreeNode | undefined>child.parent) = undefined;
+    (<T | undefined>child.parent) = undefined;
     return true;
   }
 
-  public removeData(data: ITreeNodeData): boolean {
+  public removeData(data: U): boolean {
     const index = this.#data.indexOf(data);
     if (index === -1) return false;
     this.#data.splice(index, 1);
@@ -334,15 +329,15 @@ export class TreeNode implements ITreeNode {
     return true;
   }
 
-  public traverse(callback: (node: ITreeNode) => void): void {
-    callback(this);
+  public traverse(callback: (node: T) => void): void {
+    callback(<T><unknown>this);
 
     for(let i = 0; i < this.children.length; i++)
       this.children[i].traverse(callback);
   }
 
   public updateVersion(): void {
-    let node = <ITreeNode>this;
+    let node = <AbstractTreeNode<any, any>>this;
     while (node.parent) {
       node = node.parent;
       (<any>node.version) = this.#uuidGenerator.create();

package/src/implementation/AbstractTreeNodeData.ts

@@ -3,7 +3,7 @@ import { UuidGenerator, EventEngine, EVENTTYPE } from '@shapediver/viewer.shared
 
 import { ITreeNodeData } from '../interfaces/ITreeNodeData'
 
-export abstract class AbstractTreeNodeData implements ITreeNodeData {
+export abstract class AbstractTreeNodeData<T extends ITreeNodeData<any>> implements ITreeNodeData<T> {
   // #region Properties (3)
 
   #version: string;
@@ -56,7 +56,10 @@ export abstract class AbstractTreeNodeData implements ITreeNodeData {
   /**
    * Clones the tree node data.
    */
-  public abstract clone(): ITreeNodeData;
+  public clone(): T {
+    const clone = new (<any>this.constructor);
+    return clone;
+  };
 
   // #endregion Public Abstract Methods (1)
 }

package/src/implementation/three/AbstractTreeNodeDataThreeJs.ts

@@ -0,0 +1,11 @@
+import { ITreeNodeDataThreeJs } from "../../interfaces/three/ITreeNodeDataThreeJs";
+import { AbstractTreeNodeData } from "../AbstractTreeNodeData";
+
+export abstract class AbstractTreeNodeDataThreeJs extends AbstractTreeNodeData<ITreeNodeDataThreeJs> implements ITreeNodeDataThreeJs {
+    #threeJsObject: { [key: string]: THREE.Object3D | THREE.BufferGeometry | THREE.Material | undefined } = {};
+    #updateCallbackThreeJsObject: ((newObj: THREE.Object3D | THREE.BufferGeometry | THREE.Material | undefined, oldObj: THREE.Object3D | THREE.BufferGeometry | THREE.Material | undefined, viewport: string) => void) | null = null;
+
+    public get threeJsObject(): { [key: string]: THREE.Object3D | THREE.BufferGeometry | THREE.Material | undefined } {
+        return this.#threeJsObject;
+    }
+}

package/src/implementation/three/Tree.ts

@@ -0,0 +1,12 @@
+import { singleton } from "tsyringe";
+import { ITreeNodeThreeJs } from "../../interfaces/three/ITreeNodeThreeJs";
+import { ITreeThreeJs } from "../../interfaces/three/ITreeThreeJs";
+import { AbstractTree } from "../AbstractTree";
+import { TreeNodeThreeJs } from "./TreeNodeThreejs";
+
+@singleton()
+export class Tree extends AbstractTree<ITreeNodeThreeJs> implements ITreeThreeJs {
+    constructor() {
+        super(new TreeNodeThreeJs('root'))
+    }
+}

package/src/implementation/three/TreeNodeThreeJs.ts

@@ -0,0 +1,20 @@
+import { ITreeNodeDataThreeJs } from "../../interfaces/three/ITreeNodeDataThreeJs";
+import { ITreeNodeThreeJs } from "../../interfaces/three/ITreeNodeThreeJs";
+import { AbstractTreeNode } from "../AbstractTreeNode";
+
+export class TreeNodeThreeJs extends AbstractTreeNode<ITreeNodeThreeJs, ITreeNodeDataThreeJs> implements ITreeNodeThreeJs {
+    #threeJsObject: { [key: string]: THREE.Object3D } = {};
+    #updateCallbackThreeJsObject: ((newObj: THREE.Object3D, oldObj: THREE.Object3D, viewport: string) => void) | null = null;
+
+    public get threeJsObject(): { [key: string]: THREE.Object3D } {
+        return this.#threeJsObject;
+    }
+
+    public get updateCallbackThreeJsObject(): ((newObj: THREE.Object3D, oldObj: THREE.Object3D, viewport: string) => void) | null {
+        return this.#updateCallbackThreeJsObject;
+    }
+
+    public set updateCallbackThreeJsObject(value: ((newObj: THREE.Object3D, oldObj: THREE.Object3D, viewport: string) => void) | null) {
+        this.#updateCallbackThreeJsObject = value;
+    }
+}

package/src/index.ts

@@ -1,21 +1,19 @@
-import { ITreeNodeData } from './interfaces/ITreeNodeData'
-import { AbstractTreeNodeData } from './implementation/AbstractTreeNodeData'
-import { ISDObject } from './interfaces/ISDObject'
-import { ITree } from './interfaces/ITree'
-import { Tree } from './implementation/Tree'
-import { ITransformation, ITreeNode } from './interfaces/ITreeNode'
-import { TreeNode } from './implementation/TreeNode'
+import { ITransformation } from './interfaces/ITreeNode'
+import { TreeNodeThreeJs } from './implementation/three/TreeNodeThreejs'
+import { ITreeNodeThreeJs } from './interfaces/three/ITreeNodeThreeJs'
+import { Tree } from './implementation/three/Tree'
+import { ITreeThreeJs } from './interfaces/three/ITreeThreeJs'
+import { ITreeNodeDataThreeJs } from './interfaces/three/ITreeNodeDataThreeJs'
+import { AbstractTreeNodeDataThreeJs } from './implementation/three/AbstractTreeNodeDataThreeJs'
 
 export {
-    ITree, Tree
+    ITreeThreeJs as ITree, Tree
 }
 
 export {
-    ITreeNode, TreeNode, ITransformation
+    ITreeNodeThreeJs as ITreeNode, TreeNodeThreeJs as TreeNode, ITransformation
 }
 
 export {
-    ITreeNodeData,
-    ISDObject,
-    AbstractTreeNodeData
+    ITreeNodeDataThreeJs as ITreeNodeData, AbstractTreeNodeDataThreeJs as AbstractTreeNodeData
 }

package/src/interfaces/ITree.ts

@@ -1,9 +1,13 @@
 import { ITreeNode } from "./ITreeNode";
+import { ITreeNodeData } from "./ITreeNodeData";
 
-export interface ITree {
+export interface ITree<T extends ITreeNode<any, ITreeNodeData<any>>> {
     // #region Properties (1)
 
-    readonly root: ITreeNode;
+    /**
+     * The root of the tree.
+     */
+    readonly root: T;
 
     // #endregion Properties (1)
 
@@ -16,7 +20,7 @@ export interface ITree {
      * @param parent the targeted parent node
      * @param root optional root at which the process begins, root node will be used per default
      */
-    addNode(node: ITreeNode, parent?: ITreeNode, root?: ITreeNode): boolean;
+    addNode(node: T, parent?: T, root?: T): boolean;
 
     /**
      * Add the node at the corresponding path. (paths are dot separated ids)
@@ -25,7 +29,7 @@ export interface ITree {
      * @param path the path at which the node should be added
      * @param root optional root at which the process begins, root node will be used per default
      */
-    addNodeAtPath(node: ITreeNode, path?: string, root?: ITreeNode): boolean;
+    addNodeAtPath(node: T, path?: string, root?: T): boolean;
 
     /**
      * Get the node at the provided path.
@@ -34,7 +38,7 @@ export interface ITree {
      * @param root 
      * @returns 
      */
-    getNodeAtPath(path?: string, root?: ITreeNode): ITreeNode | null;
+    getNodeAtPath(path?: string, root?: T): T | null;
 
     /**
      * Remove a node from the tree.
@@ -42,7 +46,7 @@ export interface ITree {
      * @param node the node to remove 
      * @param root optional root at which the process begins, root node will be used per default
      */
-    removeNode(node: ITreeNode, root?: ITreeNode): boolean;
+    removeNode(node: T, root?: T): boolean;
 
     /**
      * Remove a node via the path of it.
@@ -50,7 +54,7 @@ export interface ITree {
      * @param path the path of the node to be removed
      * @param root optional root at which the process begins, root node will be used per default
      */
-    removeNodeAtPath(path: string, root?: ITreeNode): boolean;
+    removeNodeAtPath(path: string, root?: T): boolean;
 
     // #endregion Public Methods (5)
 }

package/src/interfaces/ITreeNode.ts

@@ -1,7 +1,6 @@
 import { mat4 } from 'gl-matrix'
 import { IBox } from '@shapediver/viewer.shared.math'
 import { ITreeNodeData } from './ITreeNodeData'
-import { ISDObject } from './ISDObject'
 
 export interface ITransformation {
     // #region Properties (2)
@@ -12,147 +11,182 @@ export interface ITransformation {
     // #endregion Properties (2)
 }
 
-export interface ITreeNode {
-    // #region Properties (16)
-
-    readonly children: ITreeNode[];
-    readonly data: ITreeNodeData[];
+export interface ITreeNode<T extends ITreeNode<any, ITreeNodeData<any>>, U extends ITreeNodeData<any>> {
+    // #region Properties (17)
 
+    /**
+     * The bounding box of this tree node.
+     */
+    readonly boundingBox: IBox;
+    /**
+     * The children of this tree node. Can be added and remove via {@link addChild} and {@link removeChild}. 
+     */
+    readonly children: T[];
+    /**
+     * The data of this tree node. 
+     * The data can include Geometry, Materials, Lights, Cameras, but also informational or custom data.
+     * 
+     * Can be added and remove via {@link addData} and {@link removeData}. 
+     */
+    readonly data: U[];
+    /**
+     * The ID of the tree node.
+     */
     readonly id: string;
-    readonly originalId: string;
+    /**
+     * The name of the tree node.
+     */
     readonly name: string;
-    readonly version: string;
-    readonly parent?: ITreeNode;
-
+    /**
+     * The matrix of the tree node.
+     * This is computed via all transformations in the {@link transformations} property.
+     */
     readonly nodeMatrix: mat4;
+    /**
+     * The original ID of the tree node, if it was copied.
+     */
+    readonly originalId: string;
+    /**
+     * The parent of the tree node.
+     * This property is automatically managed by {@link addChild} and {@link removeChild}. 
+     */
+    readonly parent?: T;
+    /**
+     * The version of the tree node.
+     * If the version changes, the node will be marked for an update.
+     * A version change can be triggered via {@link updateVersion}. 
+     */
+    readonly version: string;
+    /**
+     * The world matrix of the tree node.
+     * This includes also the transformations of all parents.
+     */
     readonly worldMatrix: mat4;
 
-    readonly boundingBox: IBox;
-    readonly transformedNodes: {
-        [key: string]: ISDObject
-    };
-
+    /**
+     * The inverse matrices for the bones, if specified.
+     */
+    boneInverses: mat4[];
+    /**
+     * The optional bones that build a skeleton for animations.
+     */
+    bones: T[];
+    /**
+     * The viewports to exclude this tree node from.
+     */
     excludeViewports: string[];
+    /**
+     * The viewports to restrict this tree node to.
+     */
     restrictViewports: string[];
-
+    /**
+     * Property to mark this node as a skin node. (default: false)
+     */
+    skinNode: boolean;
+    /**
+     * The transformation to be applied to this tree node.
+     */
     transformations: ITransformation[];
+    /**
+     * Option to make this tree node visible. (default: true)
+     */
     visible: boolean;
 
-    skinNode: boolean;
-    bones: ITreeNode[];
-    boneInverses: mat4[];
-
-    // #endregion Properties (16)
+    // #endregion Properties (17)
 
-    // #region Public Methods (13)
+    // #region Public Methods (17)
 
     /**
      * Add a child to the children of this node.
      * 
      * @param child the child to add
      */
-    addChild(child: ITreeNode): boolean;
-
+    addChild(child: T): boolean;
     /**
      * Add a data item to node.
      * 
      * @param data the data to add
      */
-    addData(data: ITreeNodeData): boolean;
-
+    addData(data: U): boolean;
     /**
      * Add a transformation to this node.
      * 
      * @param transformation the transformation to add
      */
     addTransformation(transformation: ITransformation): boolean;
-
     /**
      * Clones this node and all its children. 
      * The data objects like GeometryData, MaterialData, etc. are cloned as well. 
      * Depending on the size of the node and the amount of children, this can therefore be relatively slow.
      */
-    clone(): ITreeNode;
-
+    clone(): T;
     /**
      * Clones this node and all its children. 
      * The data objects like GeometryData, MaterialData, etc. are not copied in this case.
      */
-    cloneInstance(): ITreeNode;
-
+    cloneInstance(): T;
     /**
      * Returns the child with the specified id
     */
-    getChild(id: string): ITreeNode | undefined;
-
+    getChild(id: string): T | undefined;
     /**
      * Returns the data item with the specified id
     */
-    getData(id: string): ITreeNodeData | undefined;
-
-    /**
-     * Returns the transformation with the specified id
-    */
-    getTransformation(id: string): ITransformation | undefined;
-
+    getData(id: string): U | undefined;
     /**
      * Return the path to this node.
      */
     getPath(): string;
-
+    /**
+     * Returns the transformation with the specified id
+    */
+    getTransformation(id: string): ITransformation | undefined;
     /**
      * Check for existence of a child from the children of this node.
      * 
      * @param child the child to check
      */
-    hasChild(child: ITreeNode): boolean;
-
+    hasChild(child: T): boolean;
     /**
      * Check for existence of a data item of this node.
      * 
      * @param data the data item to check
      */
-    hasData(data: ITreeNodeData): boolean;
-
+    hasData(data: U): boolean;
     /**
      * Check for existence of a transformation of this node.
      * 
      * @param data the transformation to check
      */
     hasTransformation(transformation: ITransformation): boolean;
-
     /**
      * Remove a child from the children of this node.
      * 
      * @param child the child to remove
      */
-    removeChild(child: ITreeNode): boolean;
-
+    removeChild(child: T): boolean;
     /**
      * Remove a data item from this node.
      * 
      * @param data the data to remove
      */
-    removeData(data: ITreeNodeData): boolean;
-
+    removeData(data: U): boolean;
     /**
      * Remove a transformation from this node.
      * 
      * @param transformation the transformation to remove
      */
     removeTransformation(transformation: ITransformation): boolean;
-
     /**
      * Traverse this node and all it's children and executes the callback for all of them
      * 
      * @param callback 
      */
-    traverse(callback: (node: ITreeNode) => void): void;
-
+    traverse(callback: (node: T) => void): void;
     /**
-     * Update the version
+     * Update the version.
      */
     updateVersion(): void;
 
-    // #endregion Public Methods (13)
+    // #endregion Public Methods (17)
 }

package/src/interfaces/ITreeNodeData.ts

@@ -1,6 +1,29 @@
-export interface ITreeNodeData {
+export interface ITreeNodeData<T extends ITreeNodeData<any>> {
+  // #region Properties (2)
+
+  /**
+   * The ID of the tree node data.
+   */
   id: string;
+  /**
+   * The version of the tree node data.
+   * If the version changes, the node data will be marked for an update.
+   * A version change can be triggered via {@link updateVersion}. 
+   */
   version: string;
+
+  // #endregion Properties (2)
+
+  // #region Public Methods (2)
+
+  /**
+   * Clones this node tree data. 
+   */
+  clone(): T;
+  /**
+   * Update the version.
+   */
   updateVersion(): void;
-  clone(): ITreeNodeData;
+
+  // #endregion Public Methods (2)
 }