@zephyr3d/scene 0.9.4 → 0.9.6

package/dist/src/scene/scene_node.js

@@ -1,732 +0,0 @@
-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