@zephyr3d/scene 0.6.0 → 0.7.0

package/dist/scene/scene_node.js

@@ -1,97 +1,334 @@
-import { XForm } from './xform.js';
+import { makeObservable, Disposable, randomUUID, DRef, ObservableVector3, ObservableQuaternion, Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';
+import { AnimationSet } from '../animation/animationset.js';
+import '../animation/eulerrotationtrack.js';
+import '../values.js';
+import { getEngine } from '../app/api.js';
+import '../animation/skeleton.js';
 
 /**
- * The base class for any kind of scene objects
+ * The base class of all scene graph objects.
  *
  * @remarks
- * We use a data structure called SceneGraph to store scenes,
- * which consists of a couple of scene objects forming a
- * hierarchical structure. This is the base class for any kind
- * of the scene object, which contains the basic properties such
- * as position, rotation, and scale of the object.
+ * Responsibilities:
+ * - Defines hierarchical transform (position, rotation, scale) with lazily computed matrices.
+ * - Integrates with the scene graph (parent/children, attachment notifications).
+ * - Provides traversal utilities (`iterate`, `iterateBottomToTop`, `traverse`).
+ * - Manages visibility state and CPU/GPU picking flags.
+ * - Computes and caches local/world bounding volumes, notifies scene for spatial updates.
+ * - Supports cloning and shared model instancing.
+ * - Emits events on visibility, transform, bounding volume, attachment, and disposal.
+ *
+ * Performance:
+ * - `localMatrix`, `worldMatrix`, and `invWorldMatrix` are cached until invalidated.
+ * - Transform mutations and `invalidateBoundingVolume` update caches and spatial structures.
+ *
+ * Events:
+ * - `nodeattached`, `noderemoved`, `visiblechanged`, `transformchanged`, `bvchanged`, `dispose`.
  *
  * @public
- */ class SceneNode extends XForm {
+ */ class SceneNode extends makeObservable(Disposable)() {
+    static _runTimeId = 1;
     /*
   static readonly PICK_INHERITED = -1;
   static readonly PICK_DISABLED = 0;
   static readonly PICK_ENABLED = 1;
-  */ static BBOXDRAW_INHERITED = -1;
-    static BBOXDRAW_DISABLED = 0;
-    static BBOXDRAW_LOCAL = 1;
-    static BBOXDRAW_WORLD = 2;
-    /** @internal */ _clipMode;
-    /** @internal */ _boxDrawMode;
-    /** @internal */ _visible;
-    /** @internal */ _pickMode;
-    /** @internal */ _name;
-    /** @internal */ _scene;
-    /** @internal */ _bv;
-    /** @internal */ _bvDirty;
-    /** @internal */ _bvWorld;
-    /** @internal */ _placeToOctree;
-    /**
-   * Creates a new scene node
-   * @param scene - Which scene the node belongs to
+  */ /** Bounding-box draw mode inherited from nearest graph ancestor. */ static BBOXDRAW_INHERITED = -1;
+    /** Disable bounding-box visualization. */ static BBOXDRAW_DISABLED = 0;
+    /** Draw local-space bounding box. */ static BBOXDRAW_LOCAL = 1;
+    /** Draw world-space bounding box. */ static BBOXDRAW_WORLD = 2;
+    /** @internal Runtime unique id. */ _runtimeId;
+    /** @internal Unique persistent id. */ _id;
+    /** @internal Prefab id */ _prefabId;
+    /** @internal Animation set reference. */ _animationSet;
+    /** @internal Optional shared model reference for instancing. */ _sharedModel;
+    /** @internal */ _jointTypeT;
+    /** @internal */ _jointTypeS;
+    /** @internal */ _jointTypeR;
+    /** @internal Clip test flag used by renderer. */ _clipMode;
+    /** @internal Bounding-box visualization mode. */ _boxDrawMode;
+    /** @internal Visibility state ('visible'|'hidden'|'inherit'). */ _visible;
+    /** @internal CPU picking flag. */ _pickable;
+    /** @internal GPU picking flag. */ _gpuPickable;
+    /** @internal Friendly name for debugging/UI. */ _name;
+    /** @internal Owning scene. */ _scene;
+    /** @internal Local-space bounding volume cache. */ _bv;
+    /** @internal True if local BV needs recomputing. */ _bvDirty;
+    /** @internal World-space bounding volume cache. */ _bvWorld;
+    /** @internal Whether this node participates in scene spatial structures (octree). */ _placeToOctree;
+    /** @internal If true, this node cannot be cloned/attached as a child (engine policy). */ _sealed;
+    /** @internal Parent node. */ _parent;
+    /** @internal Children list (DRef for memory/resource mgmt). */ _children;
+    /** @internal Local position (observable). */ _position;
+    /** @internal Local scale (observable). */ _scaling;
+    /** @internal Local rotation (observable quaternion). */ _rotation;
+    /** @internal Local transform matrix cache. */ _localMatrix;
+    /** @internal World transform matrix cache. */ _worldMatrix;
+    /** @internal Determinant of world transform (cached). */ _worldMatrixDet;
+    /** @internal Inverse world transform matrix cache. */ _invWorldMatrix;
+    /** @internal Scratch local matrix to avoid allocations. */ _tmpLocalMatrix;
+    /** @internal Scratch world matrix to avoid allocations. */ _tmpWorldMatrix;
+    /** @internal Monotonically increasing tag for transform changes. */ _transformTag;
+    /** @internal Shared callback used by observables on transform mutation. */ _transformChangeCallback;
+    /** @internal Arbitrary metadata payload for this node. */ _metaData;
+    /** @internal If true, suppress transform-change callbacks (during bulk updates). */ _disableCallback;
+    /** @internal User-attached script entry (engine-defined). */ _script;
+    /**
+   * Construct a scene node.
+   *
+   * @remarks
+   * If a `scene` is provided and this is not the root node, the node is reparented
+   * under the scene's root immediately.
+   *
+   * @param scene - Scene that will own this node.
    */ constructor(scene){
         super();
+        this._runtimeId = SceneNode._runTimeId++;
+        this._id = randomUUID();
+        this._prefabId = '';
         this._scene = scene;
         this._name = '';
+        this._animationSet = new DRef();
+        this._sharedModel = new DRef();
+        this._jointTypeT = 'none';
+        this._jointTypeS = 'none';
+        this._jointTypeR = 'none';
         this._bv = null;
         this._bvWorld = null;
         this._bvDirty = true;
         this._clipMode = true;
         this._boxDrawMode = SceneNode.BBOXDRAW_DISABLED;
         this._visible = 'inherit';
-        this._pickMode = false;
+        this._pickable = false;
+        this._gpuPickable = true;
         this._placeToOctree = true;
+        this._parent = null;
+        this._sealed = false;
+        this._children = [];
+        this._transformChangeCallback = ()=>this._onTransformChanged(true);
+        this._position = new ObservableVector3(0, 0, 0);
+        this._position.callback = this._transformChangeCallback;
+        this._scaling = new ObservableVector3(1, 1, 1);
+        this._scaling.callback = this._transformChangeCallback;
+        this._rotation = new ObservableQuaternion();
+        this._rotation.callback = this._transformChangeCallback;
+        this._worldMatrix = null;
+        this._worldMatrixDet = null;
+        this._invWorldMatrix = null;
+        this._localMatrix = null;
+        this._transformTag = 0;
+        this._disableCallback = false;
+        this._tmpLocalMatrix = Matrix4x4.identity();
+        this._tmpWorldMatrix = Matrix4x4.identity();
+        this._script = '';
+        this._metaData = null;
         if (scene && this !== scene.rootNode) {
             this.reparent(scene.rootNode);
         }
     }
-    /** @internal */ get placeToOctree() {
+    /**
+   * Whether the node should be inserted into the scene's spatial structure.
+   *
+   * @remarks
+   * Toggling this hints the scene to (re)place the node in octree/acceleration structures.
+   */ get placeToOctree() {
         return this._placeToOctree;
     }
     set placeToOctree(val) {
         if (!!val !== this._placeToOctree) {
             this._placeToOctree = !!val;
             if (this.isGraphNode()) {
-                this.scene.invalidateNodePlacement(this);
+                this.scene?.invalidateNodePlacement(this);
             }
         }
     }
     /**
-   * Name of the scene node
+   * Node's runtime unique identifier
+   */ get runtimeId() {
+        return this._runtimeId;
+    }
+    /**
+   * Node's persistent identifier.
+   *
+   * @remarks
+   * Changing this affects serialization and registry lookup; ensure uniqueness.
+   */ get persistentId() {
+        return this._id;
+    }
+    set persistentId(id) {
+        this._id = id;
+    }
+    /**
+   * If not empty, this node was loaded from a prefab
+   *
+   * @remarks
+   * Internal used for serialization
+   */ get prefabId() {
+        return this._prefabId;
+    }
+    set prefabId(id) {
+        this._prefabId = id;
+    }
+    /**
+   * Get prefab node this node belongs to, or null if this node does not belongs to any prefab
+   * @returns prefab node this node belongs to
+   */ getPrefabNode() {
+        return this._prefabId ? this : this.parent?.getPrefabNode() ?? null;
+    }
+    /**
+   * Translation type if this is a joint node of any skeleton
+   *
+   * @remarks
+   * Internal used for serialization
+   */ get jointTypeT() {
+        return this._jointTypeT;
+    }
+    set jointTypeT(val) {
+        this._jointTypeT = val;
+    }
+    /**
+   * Scale type if this is a joint node of any skeleton
+   *
+   * @remarks
+   * Internal used for serialization
+   */ get jointTypeS() {
+        return this._jointTypeS;
+    }
+    set jointTypeS(val) {
+        this._jointTypeS = val;
+    }
+    /**
+   * Rotation type if this is a joint node of any skeleton
+   *
+   * @remarks
+   * Internal used for serialization
+   */ get jointTypeR() {
+        return this._jointTypeR;
+    }
+    set jointTypeR(val) {
+        this._jointTypeR = val;
+    }
+    /**
+   * Arbitrary metadata associated with this node.
+   *
+   * @remarks
+   * Stored and transported with the node; format is application-defined.
+   */ get metaData() {
+        return this._metaData;
+    }
+    set metaData(val) {
+        this._metaData = val;
+    }
+    /**
+   * Attached script filename or identifier (engine-specific).
+   *
+   * @remarks
+   * Integrates with the engine’s scripting system if available.
+   */ get script() {
+        return this._script;
+    }
+    set script(fileName) {
+        this._script = fileName ?? '';
+    }
+    /**
+   * Display name of the node (for UI/debugging).
    */ get name() {
         return this._name;
     }
     set name(val) {
         this._name = val || '';
     }
-    /** The scene to which the node belongs */ get scene() {
+    /** The owning scene. */ get scene() {
         return this._scene;
     }
-    /** true if the node is attached to the scene node, false otherwise */ get attached() {
-        return !!this._scene?.rootNode?.isParentOf(this);
+    /**
+   * Whether this node is currently attached under the scene's root.
+   */ get attached() {
+        let node = this;
+        while(node && node !== this._scene.rootNode){
+            node = node.parent;
+        }
+        return node === this._scene.rootNode;
+    }
+    /**
+   * If true, the node is logically sealed; some operations (like cloning as child)
+   * may be restricted by engine policies.
+   */ get sealed() {
+        return this._sealed;
+    }
+    set sealed(val) {
+        this._sealed = val;
     }
     /**
-   * Check if given node is a direct child of the node
+   * Lazily created animation set for this node.
+   *
+   * @remarks
+   * Accessing this schedules the node for update in the scene.
+   */ get animationSet() {
+        if (!this._animationSet.get()) {
+            this._animationSet.set(new AnimationSet(this));
+            this.scene.queueUpdateNode(this);
+        }
+        return this._animationSet.get();
+    }
+    /**
+   * Shared model reference for instancing/streaming systems.
+   */ get sharedModel() {
+        return this._sharedModel.get();
+    }
+    set sharedModel(model) {
+        this._sharedModel.set(model);
+    }
+    /**
+   * Clone this node.
+   *
+   * @remarks
+   * If a shared model exists, it may create an instanced node. The clone is
+   * attached under the same parent; children are cloned based on `method` and `recursive`.
+   *
+   * @param method - Clone method ('deep' or 'instance').
+   * @param recursive - Whether children are cloned recursively.
+   * @returns New node instance
+   */ async clone() {
+        this.iterate((node)=>{
+            if (node.isTerrain() || node.isClipmapTerrain()) {
+                throw new Error('Cloning terrain node is not allowed');
+            }
+        });
+        const parent = this.parent;
+        const tmpParent = new SceneNode(this.scene);
+        const data = await getEngine().resourceManager.serializeObject(this);
+        const other = await getEngine().resourceManager.deserializeObject(tmpParent, data);
+        other.persistentId = randomUUID();
+        other.parent = parent;
+        tmpParent.dispose();
+        const postClonePromises = [];
+        other.iterate((node)=>{
+            const P = node.onPostClone();
+            if (P instanceof Promise) {
+                postClonePromises.push(P);
+            }
+        });
+        if (postClonePromises.length > 0) {
+            await Promise.all(postClonePromises);
+        }
+        return other;
+    }
+    /**
+   * Whether the given node is a direct child of this node.
    * @param child - The node to be checked
    * @returns true if the given node is a direct child of this node, false otherwise
    */ hasChild(child) {
-        return this._children.indexOf(child) >= 0;
+        return child && child.parent === this;
     }
     /**
-   * Removes all children from this node
+   * Remove all children from this node.
    */ removeChildren() {
         while(this._children.length){
-            this._children[0].remove();
+            this._children[0].get().remove();
         }
     }
     /**
-   * Checks if this node is the direct parent or indirect parent of a given node
-   * @param child - The node to be checked
-   * @returns true if this node is the direct parent or indirect parent of the given node, false otherwise
+   * Whether this node is an ancestor (direct or indirect) of the given node.
    */ isParentOf(child) {
         while(child && child !== this){
             child = child.parent;
@@ -99,55 +336,82 @@ import { XForm } from './xform.js';
         return child === this;
     }
     /**
-   * Removes this node from it's parent
-   * @returns self
+   * Detach this node from its parent.
+   *
+   * @returns this
    */ remove() {
         this.parent = null;
         return this;
     }
     /**
-   * Traverse the entire subtree of this node by a visitor
-   * @param v - The visitor that will travel the subtree of this node
-   * @param inverse - true if traversing from bottom to top, otherwise top to bottom
-   */ traverse(v, inverse) {
-        if (inverse) {
-            for(let i = this._children.length - 1; i >= 0; i--){
-                this._children[i].traverse(v, inverse);
-            }
-            v.visit(this);
-        } else {
-            v.visit(this);
-            for (const child of this._children){
-                child.traverse(v);
-            }
+   * Depth-first traversal of this node's subtree (pre-order).
+   *
+   * @param v - Visitor invoked on each node.
+   */ traverse(v) {
+        v.visit(this);
+        for (const child of this._children){
+            child.get().traverse(v);
         }
     }
     /**
-   * Iterate self and all of the children
+   * Iterate self and descendants in pre-order.
    *
-   * @remarks
-   * DO NOT remove child duration iteration!
+   * Warning: Do not remove children during this iteration. To allow removal, use `iterateBottomToTop`.
    *
-   * @param callback - callback function that will be called on each node
+   * @param callback - Called for each node; if returns true, iteration stops.
+   * @returns true if iteration was aborted early.
    */ iterate(callback) {
-        callback(this);
+        if (callback(this)) {
+            return true;
+        }
         for (const child of this._children){
-            child.iterate(callback);
+            if (child.get().iterate(callback)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+   * Iterate self and descendants in reverse post-order (bottom-to-top).
+   *
+   * Child nodes can be safely removed during this iteration.
+   *
+   * @param callback - Called for each node; if returns true, iteration stops.
+   * @returns true if iteration was aborted early.
+   */ iterateBottomToTop(callback) {
+        for(let i = this._children.length - 1; i >= 0; i--){
+            const child = this._children[i];
+            if (child.get().iterateBottomToTop(callback)) {
+                return true;
+            }
         }
+        if (callback(this)) {
+            return true;
+        }
+        return false;
+    }
+    /** Type guard: true if this node is a graph node. */ isGraphNode() {
+        return false;
+    }
+    /** Type guard: true if this node is a light. */ isLight() {
+        return false;
     }
-    /** true if this is a graph node, false otherwise */ isGraphNode() {
+    /** Type guard: true if this node is a mesh. */ isMesh() {
         return false;
     }
-    /** true if this is a light node, false otherwise */ isLight() {
+    /** Type guard: true if this node is a water node. */ isWater() {
         return false;
     }
-    /** true if this is a mesh node, false otherwise */ isMesh() {
+    /** Type guard: true if this node is a particle system. */ isParticleSystem() {
         return false;
     }
-    /** true if this is a batch group, false otherwise */ isBatchGroup() {
+    /** Type guard: true if this node is a batch group. */ isBatchGroup() {
         return false;
     }
-    /** true if this is a terrain node, false otherwise */ isTerrain() {
+    /** Type guard: true if this node is a terrain. */ isTerrain() {
+        return false;
+    }
+    /** Type guard: true if this node is a clipmap terrain. */ isClipmapTerrain() {
         return false;
     }
     /** true if this is a camera node, false otherwise */ isCamera() {
@@ -156,10 +420,6 @@ import { XForm } from './xform.js';
     /** true if this is a punctual light node, false otherwise */ isPunctualLight() {
         return false;
     }
-    /** Disposes the node */ dispose() {
-        this.remove();
-        this.removeChildren();
-    }
     /**
    * Computes the bounding volume of the node
    * @returns The output bounding volume
@@ -191,11 +451,17 @@ import { XForm } from './xform.js';
    * @returns The world space bounding volume of the node
    */ getWorldBoundingVolume() {
         if (!this._bvWorld) {
-            this._bvWorld = this.getBoundingVolume()?.transform(this.worldMatrix) ?? null;
+            this._bvWorld = this.computeWorldBoundingVolume(this.getBoundingVolume());
         }
         return this._bvWorld;
     }
     /**
+   * Computes the world space bounding volume of the node
+   * @returns The output bounding volume
+   */ computeWorldBoundingVolume(localBV) {
+        return localBV?.transform(this.worldMatrix) ?? null;
+    }
+    /**
    * Force the bounding volume to be recalculated
    */ invalidateBoundingVolume() {
         this._bvDirty = true;
@@ -213,7 +479,7 @@ import { XForm } from './xform.js';
             } else if (this.isGraphNode()) {
                 this._scene.invalidateNodePlacement(this);
             }
-            this.dispatchEvent(this, 'bvchanged');
+            this.dispatchEvent('bvchanged', this);
         }
     }
     /** Clip mode */ get clipTestEnabled() {
@@ -238,17 +504,79 @@ import { XForm } from './xform.js';
             this._visible = val;
             if (prevHidden !== this.hidden) {
                 if (this.isGraphNode()) {
-                    this._scene.invalidateNodePlacement(this);
+                    this._scene?.invalidateNodePlacement(this);
+                }
+                let parent = this;
+                while(parent){
+                    parent.dispatchEvent('visiblechanged', this);
+                    parent = parent.parent;
                 }
                 this.notifyHiddenChanged();
             }
         }
     }
-    /** Computed value of pick mode */ get pickable() {
-        return this._pickMode;
+    /** Whether this node is enabled for CPU picking */ get pickable() {
+        return this._pickable;
     }
     set pickable(val) {
-        this._pickMode = !!val;
+        this._pickable = !!val;
+    }
+    /** Whether this node is enabled for GPU picking */ get gpuPickable() {
+        return this._gpuPickable;
+    }
+    set gpuPickable(val) {
+        this._gpuPickable = !!val;
+    }
+    /**
+   * Finds a scene node by its persistent ID.
+   *
+   * @typeParam T - Expected node type.
+   * @param id - Persistent identifier to match against `SceneNode.persistentId`.
+   * @returns The first matching node, or `null` if not found.
+   */ findNodeById(id) {
+        let node = null;
+        this.iterate((child)=>{
+            if (child.persistentId === id) {
+                node = child;
+                return true;
+            }
+        });
+        return node;
+    }
+    /**
+   * Finds a skeleton object by its persistent ID.
+   * @param id - Persistent identifier to match against `Skeleton.persistentId`.
+   * @returns The first matchign node, or `null` if not found.
+   */ findSkeletonById(id) {
+        const prefabNode = this.getPrefabNode() ?? this;
+        let sk = null;
+        prefabNode.iterate((node)=>{
+            sk = node.animationSet.skeletons.find((s)=>s.get().persistentId === id);
+            return !!sk;
+        });
+        return sk?.get() ?? null;
+    }
+    /**
+   * Finds a scene node by name.
+   *
+   * If multiple nodes share the same name, returns the first match encountered
+   * during traversal.
+   *
+   * @typeParam T - Expected node type.
+   * @param name - Node name to match.
+   * @returns The first matching node, or `null` if not found.
+   *
+   * @remarks
+   * Names are not guaranteed unique. Prefer IDs for stable references.
+   */ findNodeByName(name) {
+        let node = null;
+        this.iterate((child)=>{
+            if (child.name === name) {
+                node = child;
+                return true;
+            }
+        });
+        return node;
     }
     /** Computed value for bounding box draw mode */ get computedBoundingBoxDrawMode() {
         if (this._boxDrawMode === SceneNode.BBOXDRAW_INHERITED) {
@@ -266,48 +594,293 @@ import { XForm } from './xform.js';
     set boundingBoxDrawMode(mode) {
         this._boxDrawMode = mode;
     }
+    /** Get called when the node was just created by cloning from other node */ onPostClone() {}
+    /** Disposes the node */ onDispose() {
+        super.onDispose();
+        this.remove();
+        this.removeChildren();
+        this._animationSet?.dispose();
+        this._animationSet = null;
+        this._sharedModel?.dispose();
+        this._sharedModel = null;
+    }
     /** @internal */ _setParent(p) {
+        if (p && p._scene !== this._scene) {
+            throw new Error('Parent node and child node must belongs to the same scene');
+        }
         let lastParent = this._parent;
         let newParent = p;
         if (newParent !== lastParent) {
-            const sceneLast = this.attached ? this.scene : null;
-            const sceneNew = newParent?.attached ? newParent.scene : null;
-            const willDetach = sceneLast && sceneLast !== sceneNew;
-            const willAttach = sceneNew && sceneLast !== sceneNew;
-            willDetach && this._willDetach();
-            willAttach && this._willAttach();
-            super._setParent(newParent);
-            willDetach && this._detached();
-            willAttach && this._attached();
-        }
-        while(lastParent){
-            lastParent.dispatchEvent(this, 'noderemoved');
-            lastParent = lastParent.parent;
-        }
-        while(newParent){
-            newParent.dispatchEvent(this, 'nodeattached');
-            newParent = newParent.parent;
+            const willDetach = (!p || !p.attached) && this.attached;
+            const willAttach = !this.attached && p && p.attached;
+            if (newParent) {
+                newParent._children.push(new DRef(this));
+            }
+            if (this._parent) {
+                const index = this._parent._children.findIndex((val)=>val.get() === this);
+                this._parent.children[index].dispose();
+                this._parent._children.splice(index, 1);
+            }
+            this._parent = p;
+            this._onTransformChanged(false);
+            if (willDetach) {
+                this._detached();
+            }
+            if (willAttach) {
+                this._attached();
+            }
+            while(lastParent){
+                lastParent.dispatchEvent('noderemoved', this);
+                lastParent = lastParent.parent;
+            }
+            while(newParent){
+                newParent.dispatchEvent('nodeattached', this);
+                newParent = newParent.parent;
+            }
         }
     }
     /** @internal */ _onTransformChanged(invalidateLocal) {
-        super._onTransformChanged(invalidateLocal);
+        if (this._disableCallback) {
+            return;
+        }
+        if (invalidateLocal) {
+            this._localMatrix = null;
+        }
+        this._worldMatrix = null;
+        this._invWorldMatrix = null;
+        this._worldMatrixDet = null;
+        this._transformTag++;
+        for (const child of this._children){
+            child.get()._onTransformChanged(false);
+        }
         this.invalidateWorldBoundingVolume(true);
-        this.dispatchEvent(this, 'transformchanged');
+        this.dispatchEvent('transformchanged', this);
+    }
+    /**
+   * Get called when this node is attached to scene
+   */ _onAttached() {}
+    /**
+   * Get called when this node is detached from scene
+   */ _onDetached() {}
+    /** @internal */ _attached() {
+        this.iterate((child)=>{
+            this.scene.queueUpdateNode(child);
+            child._onAttached();
+        });
+    }
+    /** @internal */ _detached() {
+        this.iterate((child)=>{
+            child._onDetached();
+        });
     }
-    /** @internal */ _willAttach() {}
-    /** @internal */ _attached() {}
-    /** @internal */ _willDetach() {}
-    /** @internal */ _detached() {}
     /** @internal */ notifyHiddenChanged() {
         this._visibleChanged();
-        this.dispatchEvent(this, 'visiblechanged');
         for (const child of this._children){
-            if (child.showState === 'inherit') {
-                child.notifyHiddenChanged();
+            if (child.get().showState === 'inherit') {
+                child.get().notifyHiddenChanged();
             }
         }
     }
     /** @internal */ _visibleChanged() {}
+    /** Parent of the xform */ get parent() {
+        return this._parent;
+    }
+    set parent(p) {
+        p = p || null;
+        if (p !== this._parent) {
+            this._setParent(p);
+        }
+    }
+    /** Children of this xform */ get children() {
+        return this._children;
+    }
+    /**
+   * Position of the xform relative to it's parent
+   */ get position() {
+        return this._position;
+    }
+    set position(val) {
+        this._position.setXYZ(val[0], val[1], val[2]);
+    }
+    /**
+   * Scaling of the xform
+   */ get scale() {
+        return this._scaling;
+    }
+    set scale(val) {
+        this._scaling.setXYZ(val[0], val[1], val[2]);
+    }
+    /**
+   * Rotation of the xform
+   */ get rotation() {
+        return this._rotation;
+    }
+    set rotation(val) {
+        this._rotation.setXYZW(val[0], val[1], val[2], val[3]);
+    }
+    worldToThis(v, result) {
+        if (v instanceof Vector3) {
+            result = result || new Vector3();
+            this.invWorldMatrix.transformPointAffine(v, result);
+            return result;
+        } else {
+            result = result || new Vector4();
+            this.invWorldMatrix.transformAffine(v, result);
+            return result;
+        }
+    }
+    otherToThis(other, v, result) {
+        return this.worldToThis(other.thisToWorld(v, result), result);
+    }
+    thisToWorld(v, result) {
+        if (v instanceof Vector3) {
+            result = result || new Vector3();
+            this.worldMatrix.transformPointAffine(v, result);
+            return result;
+        } else {
+            result = result || new Vector4();
+            this.worldMatrix.transformAffine(v, result);
+            return result;
+        }
+    }
+    thisToOther(other, v, result) {
+        return other.worldToThis(this.thisToWorld(v, result), result);
+    }
+    /**
+   * Gets the position of the xform in world space
+   * @returns position of the xform in world space
+   */ getWorldPosition(outPos) {
+        return outPos?.setXYZ(this.worldMatrix.m03, this.worldMatrix.m13, this.worldMatrix.m23) ?? new Vector3(this.worldMatrix.m03, this.worldMatrix.m13, this.worldMatrix.m23);
+    }
+    /**
+   * Moves the xform by an offset vector
+   * @param delta - The offset vector
+   * @returns self
+   */ moveBy(delta) {
+        this._position.addBy(delta);
+        return this;
+    }
+    /**
+   * Scales the xform by a given scale factor
+   * @param factor - The scale factor
+   * @returns self
+   */ scaleBy(factor) {
+        this._scaling.mulBy(factor);
+        return this;
+    }
+    /**
+   * Sets the local transform matrix of the xform
+   * @param matrix - The transform matrix to set
+   * @returns self
+   */ setLocalTransform(matrix) {
+        this._disableCallback = true;
+        matrix.decompose(this._scaling, this._rotation, this._position);
+        this._disableCallback = false;
+        this._onTransformChanged(true);
+        /*
+    this._localMatrix = matrix;
+    this._disableCallback = true;
+    this._localMatrix.decompose(this._scaling, this._rotation, this._position);
+    this._disableCallback = false;
+    this._onTransformChanged(false);
+    */ return this;
+    }
+    /** Local transformation matrix of the xform */ get localMatrix() {
+        if (!this._localMatrix) {
+            this.calculateLocalTransform(this._tmpLocalMatrix);
+            this._localMatrix = this._tmpLocalMatrix;
+        /*
+      this._localMatrix
+        .scaling(this._scaling)
+        .rotateLeft(new Matrix4x4(this._rotation))
+        .translateLeft(this._position);
+      */ }
+        return this._localMatrix;
+    }
+    set localMatrix(matrix) {
+        this.setLocalTransform(matrix);
+    }
+    /** World transformation matrix of the xform */ get worldMatrix() {
+        if (!this._worldMatrix) {
+            this._worldMatrix = this._tmpWorldMatrix;
+            this.calculateWorldTransform(this._worldMatrix);
+        }
+        return this._worldMatrix;
+    }
+    /** The determinant of world matrix */ get worldMatrixDet() {
+        if (this._worldMatrixDet === null) {
+            this._worldMatrixDet = this.worldMatrix.det();
+        }
+        return this._worldMatrixDet;
+    }
+    /** Inverse of the world transformation matrix of the xform */ get invWorldMatrix() {
+        if (!this._invWorldMatrix) {
+            this._invWorldMatrix = Matrix4x4.invertAffine(this.worldMatrix);
+        }
+        return this._invWorldMatrix;
+    }
+    /**
+   * Calculate local transform matrix
+   * @param outMatrix - Matrix object that holds the result of calculation
+   */ calculateLocalTransform(outMatrix) {
+        outMatrix.compose(this._scaling, this._rotation, this._position);
+    }
+    /**
+   * Calculate world transform matrix
+   * @param outMatrix - Matrix object that holds the result of calculation
+   */ calculateWorldTransform(outMatrix) {
+        if (this._parent) {
+            Matrix4x4.multiplyAffine(this._parent.worldMatrix, this.localMatrix, outMatrix);
+        } else {
+            outMatrix.set(this.localMatrix);
+        }
+    }
+    /**
+   * Sets the local tranformation matrix by a look-at matrix
+   * @param eye - The eye position used to make the look-at matrix
+   * @param target - The target position used to make the look-at matrix
+   * @param up - The up vector used to make the look-at matrix
+   * @returns self
+   */ lookAt(eye, target, up) {
+        this.setLocalTransform(Matrix4x4.lookAt(eye, target, up));
+        return this;
+    }
+    /**
+   * Update node state once per-frame
+   * @param frameId - Current frame id
+   * @param elapsedInSeconds - Elapsed time from game start in seconds
+   * @param deltaInSeconds - Elapsed time since previous frame in seconds
+   */ update(frameId, elapsedInSeconds, deltaInSeconds) {
+        if (!this.attached) {
+            return;
+        }
+        const animationSet = this._animationSet.get();
+        if (animationSet) {
+            if (animationSet.numAnimations > 0 || animationSet.skeletons.length > 0) {
+                animationSet.update(deltaInSeconds);
+                this.scene.queueUpdateNode(this);
+            } else {
+                this._animationSet.dispose();
+            }
+        }
+    }
+    /**
+   * Update node state once per-camera
+   * @param _camera - Updates according to which camera
+   * @param _elapsedInSeconds - Elapsed time from game start in seconds
+   * @param _deltaInSeconds - Elapsed time since previous frame in seconds
+   */ updatePerCamera(_camera, _elapsedInSeconds, _deltaInSeconds) {}
+    /**
+   * Removes this node from it's parent and add this node to another parent node if required
+   * @param p - The new parent node that this node should be added to or null
+   * @returns self
+   */ reparent(p) {
+        this.parent = p;
+        return this;
+    }
+    /** @internal */ get transformTag() {
+        return this._transformTag;
+    }
 }
 
 export { SceneNode };