@zephyr3d/scene 0.9.2 → 0.9.4

package/dist/src/scene/scene_node.js

@@ -0,0 +1,732 @@
+import { Observable, DRef, ObservableVector3, ObservableQuaternion, Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';
+import { AnimationSet } from '../animation/animationset.js';
+import '../animation/eulerrotationtrack.js';
+import '../animation/skeleton.js';
+
+/**
+ * The base class for any kind of scene 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.
+ *
+ * @public
+ */ class SceneNode extends Observable {
+    /*
+  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 */ _id;
+    /** @internal */ _disposed;
+    /** @internal */ _animationSet;
+    /** @internal */ _sharedModel;
+    /** @internal */ _clipMode;
+    /** @internal */ _boxDrawMode;
+    /** @internal */ _visible;
+    /** @internal */ _pickable;
+    /** @internal */ _gpuPickable;
+    /** @internal */ _name;
+    /** @internal */ _scene;
+    /** @internal */ _bv;
+    /** @internal */ _bvDirty;
+    /** @internal */ _bvWorld;
+    /** @internal */ _placeToOctree;
+    /** @internal */ _sealed;
+    /** @internal */ _parent;
+    /** @internal */ _children;
+    /** @internal */ _position;
+    /** @internal */ _scaling;
+    /** @internal */ _rotation;
+    /** @internal */ _localMatrix;
+    /** @internal */ _worldMatrix;
+    /** @internal */ _worldMatrixDet;
+    /** @internal */ _invWorldMatrix;
+    /** @internal */ _tmpLocalMatrix;
+    /** @internal */ _tmpWorldMatrix;
+    /** @internal */ _transformTag;
+    /** @internal */ _transformChangeCallback;
+    /** @internal */ _metaData;
+    /** @internal */ _disableCallback;
+    /** @internal */ _script;
+    /**
+   * Creates a new scene node
+   * @param scene - Which scene the node belongs to
+   */ constructor(scene){
+        super();
+        this._id = crypto.randomUUID();
+        this._disposed = false;
+        this._scene = scene;
+        this._name = '';
+        this._animationSet = new DRef();
+        this._sharedModel = new DRef();
+        this._bv = null;
+        this._bvWorld = null;
+        this._bvDirty = true;
+        this._clipMode = true;
+        this._boxDrawMode = SceneNode.BBOXDRAW_DISABLED;
+        this._visible = 'inherit';
+        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() {
+        return this._placeToOctree;
+    }
+    set placeToOctree(val) {
+        if (!!val !== this._placeToOctree) {
+            this._placeToOctree = !!val;
+            if (this.isGraphNode()) {
+                this.scene?.invalidateNodePlacement(this);
+            }
+        }
+    }
+    /**
+   * Id of the node
+   */ get persistentId() {
+        return this._id;
+    }
+    set persistentId(id) {
+        this._id = id;
+    }
+    /**
+   * Metadata of the scene
+   */ get metaData() {
+        return this._metaData;
+    }
+    set metaData(val) {
+        this._metaData = val;
+    }
+    /**
+   * Attached scripts of this node
+   */ get script() {
+        return this._script;
+    }
+    set script(fileName) {
+        this._script = fileName ?? '';
+    }
+    /**
+   * Name of the node
+   */ get name() {
+        return this._name;
+    }
+    set name(val) {
+        this._name = val || '';
+    }
+    /** The scene to which the node belongs */ get scene() {
+        return this._scene;
+    }
+    /** true if the node is attached to a scene, false otherwise */ get attached() {
+        let node = this;
+        while(node && node !== this._scene.rootNode){
+            node = node.parent;
+        }
+        return node === this._scene.rootNode;
+    }
+    /** true if the node is sealed */ get sealed() {
+        return this._sealed;
+    }
+    set sealed(val) {
+        this._sealed = val;
+    }
+    get animationSet() {
+        if (!this._animationSet.get()) {
+            this._animationSet.set(new AnimationSet(this));
+            this.scene.queueUpdateNode(this);
+        }
+        return this._animationSet.get();
+    }
+    get sharedModel() {
+        return this._sharedModel.get();
+    }
+    set sharedModel(model) {
+        this._sharedModel.set(model);
+    }
+    /**
+   * Creates a new node by cloning this node
+   * @param method - clone method
+   * @param recursive - true if children should also be cloned, otherwise false
+   * @returns New cloned node
+   */ clone(method, recursive) {
+        const other = this._sharedModel.get() ? this._sharedModel.get().createSceneNode(this.scene, method === 'instance') : new SceneNode(this.scene);
+        other.copyFrom(this, method, recursive);
+        other.parent = this.parent;
+        return other;
+    }
+    /**
+   * Copy properties from other node
+   * @param other - Other node to copy properties from
+   * @param method - Clone method
+   * @param recursive - true if children of the node to copy from should be cloned and copied to this node, otherwise, children of the node to copy from will not be copied.
+   */ copyFrom(other, method, recursive) {
+        if (other.disposed || this.disposed) {
+            console.error('SceneNode.copyFrom(): Cannot copy from/to disposed node');
+            return;
+        }
+        if (other.scene !== this.scene) {
+            console.error('SceneNode.copyFrom(): Cannot copy from/to node which belongs to another scene');
+            return;
+        }
+        this.clipTestEnabled = other.clipTestEnabled;
+        this.boundingBoxDrawMode = other.boundingBoxDrawMode;
+        this.showState = other.showState;
+        this.pickable = other.pickable;
+        this.placeToOctree = other.placeToOctree;
+        this.position.set(other.position);
+        this.scale.set(other.scale);
+        this.rotation.set(other.rotation);
+        if (recursive) {
+            for (const child of other.children){
+                if (!child.get().sealed) {
+                    child.get().clone(method, true).parent = this;
+                }
+            }
+        }
+    }
+    /**
+   * Check if given node is a direct child of the 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 child && child.parent === this;
+    }
+    /**
+   * Removes all children from this node
+   */ removeChildren() {
+        while(this._children.length){
+            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
+   */ isParentOf(child) {
+        while(child && child !== this){
+            child = child.parent;
+        }
+        return child === this;
+    }
+    /**
+   * Removes this node from it's parent
+   * @returns self
+   */ 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) {
+        v.visit(this);
+        for (const child of this._children){
+            child.get().traverse(v);
+        }
+    }
+    /**
+   * Iterate self and all of the children
+   *
+   * @remarks
+   * DO NOT remove child duration iteration!
+   *
+   * @param callback - callback function that will be called on each node, if callback returns true, iteration will be stopped immediately
+   */ iterate(callback) {
+        if (!!callback(this)) {
+            return true;
+        }
+        for (const child of this._children){
+            if (!!child.get().iterate(callback)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+   * Iterate self and all of the children from bottom to top in reversed order
+   *
+   * @remarks
+   * Child can be removed duration iteration!
+   *
+   * @param callback - callback function that will be called on each node, if callback returns true, iteration will be stopped immediately
+   */ 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;
+    }
+    /** true if this is a graph node, false otherwise */ isGraphNode() {
+        return false;
+    }
+    /** true if this is a light node, false otherwise */ isLight() {
+        return false;
+    }
+    /** true if this is a mesh node, false otherwise */ isMesh() {
+        return false;
+    }
+    /** true if this is a water node, false otherwise */ isWater() {
+        return false;
+    }
+    /** true if this is a particle system node, false otherwise */ isParticleSystem() {
+        return false;
+    }
+    /** true if this is a batch group, false otherwise */ isBatchGroup() {
+        return false;
+    }
+    /** true if this is a terrain node, false otherwise */ isTerrain() {
+        return false;
+    }
+    /** true if this is a clipmap terrain node, false otherwise */ isClipmapTerrain() {
+        return false;
+    }
+    /** true if this is a camera node, false otherwise */ isCamera() {
+        return false;
+    }
+    /** true if this is a punctual light node, false otherwise */ isPunctualLight() {
+        return false;
+    }
+    /** Disposes the node */ dispose() {
+        this._disposed = true;
+        this.remove();
+        this.removeChildren();
+        this._animationSet?.dispose();
+        this._animationSet = null;
+        this._sharedModel?.dispose();
+        this._sharedModel = null;
+    }
+    /**
+   * Whether this node was disposed
+   */ get disposed() {
+        return this._disposed;
+    }
+    /**
+   * Computes the bounding volume of the node
+   * @returns The output bounding volume
+   */ computeBoundingVolume() {
+        return null;
+    }
+    /**
+   * Gets the bounding volume of the node
+   * @returns The bounding volume of the node
+   */ getBoundingVolume() {
+        if (this._bvDirty) {
+            this._bv = this.computeBoundingVolume();
+            this._bvDirty = false;
+        }
+        return this._bv;
+    }
+    /**
+   * Sets the bounding volume of the node
+   * @param bv - The bounding volume to set
+   */ setBoundingVolume(bv) {
+        if (bv !== this._bv) {
+            this._bv = bv;
+            this._bvDirty = !this._bv;
+            this.invalidateWorldBoundingVolume(false);
+        }
+    }
+    /**
+   * Gets the world space bounding volume of the node
+   * @returns The world space bounding volume of the node
+   */ getWorldBoundingVolume() {
+        if (!this._bvWorld) {
+            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;
+        this.invalidateWorldBoundingVolume(false);
+    }
+    /** Force the world space bounding volume to be recalculated */ invalidateWorldBoundingVolume(transformChanged) {
+        this._bvWorld = null;
+        if (this._scene) {
+            if (transformChanged) {
+                this.iterate((node)=>{
+                    if (node.isGraphNode()) {
+                        this._scene.invalidateNodePlacement(node);
+                    }
+                });
+            } else if (this.isGraphNode()) {
+                this._scene.invalidateNodePlacement(this);
+            }
+            this.dispatchEvent('bvchanged', this);
+        }
+    }
+    /** Clip mode */ get clipTestEnabled() {
+        return this._clipMode;
+    }
+    set clipTestEnabled(val) {
+        this._clipMode = val;
+    }
+    /** Computed value of show state */ get hidden() {
+        let node = this;
+        while(node && node._visible === 'inherit'){
+            node = node.parent;
+        }
+        return node ? node._visible === 'hidden' : false;
+    }
+    /** Show state */ get showState() {
+        return this._visible;
+    }
+    set showState(val) {
+        if (val !== this._visible) {
+            const prevHidden = this.hidden;
+            this._visible = val;
+            if (prevHidden !== this.hidden) {
+                if (this.isGraphNode()) {
+                    this._scene?.invalidateNodePlacement(this);
+                }
+                let parent = this;
+                while(parent){
+                    parent.dispatchEvent('visiblechanged', this);
+                    parent = parent.parent;
+                }
+                this.notifyHiddenChanged();
+            }
+        }
+    }
+    /** Whether this node is enabled for CPU picking */ get pickable() {
+        return this._pickable;
+    }
+    set pickable(val) {
+        this._pickable = !!val;
+    }
+    /** Whether this node is enabled for GPU picking */ get gpuPickable() {
+        return this._gpuPickable;
+    }
+    set gpuPickable(val) {
+        this._gpuPickable = !!val;
+    }
+    /** Computed value for bounding box draw mode */ get computedBoundingBoxDrawMode() {
+        if (this._boxDrawMode === SceneNode.BBOXDRAW_INHERITED) {
+            let parent = this.parent;
+            while(parent && !parent.isGraphNode()){
+                parent = parent.parent;
+            }
+            return parent?.computedBoundingBoxDrawMode ?? SceneNode.BBOXDRAW_DISABLED;
+        }
+        return this._boxDrawMode;
+    }
+    /** Bounding box draw mode */ get boundingBoxDrawMode() {
+        return this._boxDrawMode;
+    }
+    set boundingBoxDrawMode(mode) {
+        this._boxDrawMode = mode;
+    }
+    /** @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 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) {
+        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('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)=>{
+            child._onAttached();
+        });
+    }
+    /** @internal */ _detached() {
+        this.iterate((child)=>{
+            child._onDetached();
+        });
+    }
+    /** @internal */ notifyHiddenChanged() {
+        this._visibleChanged();
+        for (const child of this._children){
+            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) {
+        const animationSet = this.animationSet;
+        if (animationSet) {
+            animationSet.update(deltaInSeconds);
+            this.scene.queueUpdateNode(this);
+        }
+    }
+    /**
+   * 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 };
+//# sourceMappingURL=scene_node.js.map