@needle-tools/engine 2.36.0-pre → 2.38.0-pre

package/src/engine/engine_physics.types.ts

@@ -0,0 +1,28 @@
+
+
+export enum CollisionDetectionMode {
+  Discrete = 0,
+  Continuous = 1,
+}
+
+export enum RigidbodyConstraints {
+  None = 0,
+  FreezePositionX = 2,
+  FreezePositionY = 4,
+  FreezePositionZ = 8,
+  FreezePosition = 14,
+  FreezeRotationX = 16,
+  FreezeRotationY = 32,
+  FreezeRotationZ = 64,
+  FreezeRotation = 112,
+  FreezeAll = 126,
+}
+
+
+export enum Axes {
+  None = 0,
+  X = 2,
+  Y = 4,
+  Z = 8,
+  All = ~0,
+}

package/src/engine/engine_serialization_core.ts

@@ -3,7 +3,7 @@ import { getParam } from "./engine_utils";
 import { Object3D } from "three";
 import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
-import { SourceIdentifier } from "./engine_types";
+import { IComponent, SourceIdentifier } from "./engine_types";
 import { debugExtension } from "../engine/engine_default_parameters";
 import { LogType, showBalloonMessage } from "./debug/debug";
 import { isLocalNetwork } from "./engine_networking_utils";
@@ -11,6 +11,7 @@ import { $BuiltInTypeFlag } from "./engine_typestore";
 
 const debug = getParam("debugserializer");
 
+
 export type Constructor<T> = { new(...args: any[]): T };
 export declare type NodeToObjectMap = { [nodeId: string]: Object3D };
 export declare type ObjectToNodeMap = { [uuid: string]: number };
@@ -516,6 +517,10 @@ function setBuffer(value): Array<any> {
 }
 
 
+/** set to true while assigning properties during instantiation. 
+ * Used for validate decorator to not invoke callbacks on components that are currently in the process of being built */
+export const $isAssigningProperties = Symbol("assigned component properties");
+
 // const developmentMode = getParam("dev")
 
 /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
@@ -540,6 +545,7 @@ export function assign(target: any, source: any) {
     // if (developmentMode)
     //     onlyDeclared = false;
 
+    target[$isAssigningProperties] = true;
     for (const key of Object.keys(source)) {
         const desc = getPropertyDescriptor(target, key);
         if (onlyDeclared && desc === undefined) continue;
@@ -550,6 +556,7 @@ export function assign(target: any, source: any) {
             target[key] = source[key];
         }
     }
+    delete target[$isAssigningProperties];
 }
 
 // we need to recurse because the property might be defined in a base class

package/src/engine/engine_setup.ts

@@ -58,6 +58,7 @@ export class ContextArgs {
 	alias: string | undefined | null = undefined;
 	domElement: HTMLElement | null;
 	renderer?: THREE.WebGLRenderer = undefined;
+	hash?: string;
 
 	constructor(domElement: HTMLElement | null) {
 		this.domElement = domElement ?? document.body;
@@ -70,7 +71,8 @@ export enum FrameEvent {
 	LateUpdate = 2,
 	OnBeforeRender = 3,
 	OnAfterRender = 4,
-	PhysicsStep = 10,
+	PrePhysicsStep = 9,
+	PostPhysicsStep = 10,
 }
 
 export enum XRSessionMode {
@@ -81,12 +83,12 @@ export enum XRSessionMode {
 export declare type OnBeforeRenderCallback = (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group) => void
 
 
-export function registerComponent(script : IComponent, context?: Context) {
-    if (!script) return;
-    const new_scripts = context?.new_scripts ?? Context.Current.new_scripts;
-    if (!new_scripts.includes(script)) {
-        new_scripts.push(script);
-    }
+export function registerComponent(script: IComponent, context?: Context) {
+	if (!script) return;
+	const new_scripts = context?.new_scripts ?? Context.Current.new_scripts;
+	if (!new_scripts.includes(script)) {
+		new_scripts.push(script);
+	}
 }
 
 export class Context {
@@ -105,13 +107,16 @@ export class Context {
 	alias: string | undefined | null;
 	isManagedExternally: boolean = false;
 
+	/** used to append to loaded assets */
+	hash?: string;
+
 	domElement: HTMLElement;
 	get resolutionScaleFactor() { return this._resolutionScaleFactor; }
 	/** use to scale the resolution up or down of the renderer. default is 1 */
-	set resolutionScaleFactor(val: number) { 
-		if(val === this._resolutionScaleFactor) return;
-		if(typeof val !== "number") return;
-		if(val <= 0) {
+	set resolutionScaleFactor(val: number) {
+		if (val === this._resolutionScaleFactor) return;
+		if (typeof val !== "number") return;
+		if (val <= 0) {
 			console.error("Invalid resolution scale factor", val);
 			return;
 		}
@@ -124,7 +129,9 @@ export class Context {
 	get domX(): number { return this.domElement.offsetLeft; }
 	get domY(): number { return this.domElement.offsetTop; }
 	get isInXR() { return this.renderer.xr?.isPresenting || false; }
-	xrSessionMode : XRSessionMode | undefined = undefined;
+	xrSessionMode: XRSessionMode | undefined = undefined;
+	get isInVR() { return this.xrSessionMode === XRSessionMode.ImmersiveVR; }
+	get isInAR() { return this.xrSessionMode === XRSessionMode.ImmersiveAR; }
 	get xrSession() { return this.renderer.xr?.getSession(); }
 	get arOverlayElement(): HTMLElement {
 		const el = this.domElement as any;
@@ -182,7 +189,7 @@ export class Context {
 	rendererData: RendererData;
 	addressables: Addressables;
 	lightmaps: ILightDataRegistry;
-	players : PlayerViewManager;
+	players: PlayerViewManager;
 
 	private _sizeChanged: boolean = false;
 	private _isCreated: boolean = false;
@@ -193,6 +200,7 @@ export class Context {
 		this.name = args?.name || "";
 		this.alias = args?.alias;
 		this.domElement = args?.domElement || document.body;
+		this.hash = args?.hash;
 		if (args?.renderer) {
 			this.renderer = args.renderer;
 			this.isManagedExternally = true;
@@ -232,7 +240,7 @@ export class Context {
 		this.lightmaps = new LightDataRegistry(this);
 		this.players = new PlayerViewManager(this);
 
-		window.addEventListener('resize', () => this._sizeChanged = true );
+		window.addEventListener('resize', () => this._sizeChanged = true);
 		const ro = new ResizeObserver(_ => this._sizeChanged = true);
 		ro.observe(this.domElement);
 	}
@@ -335,13 +343,13 @@ export class Context {
 	}
 
 	removeCamera(cam?: Camera | null) {
-		if(!cam) return;
+		if (!cam) return;
 		const index = this._cameraStack.indexOf(cam);
 		if (index >= 0) this._cameraStack.splice(index, 1);
 
 		if (this.mainCameraComponent === cam) {
 			this.mainCameraComponent = undefined;
-		
+
 			if (this._cameraStack.length > 0) {
 				const last = this._cameraStack[this._cameraStack.length - 1];
 				this.setCurrentCamera(last);
@@ -400,6 +408,10 @@ export class Context {
 	}
 
 	private async internalOnCreate(buildScene: (context: Context, opts?: LoadingOptions) => Promise<void>, opts?: LoadingOptions) {
+
+		// TODO: we could configure if we need physics
+		await this.physics.createWorld();
+
 		// load and create scene
 		let prepare_succeeded = true;
 		try {
@@ -562,11 +574,12 @@ export class Context {
 		this.executeCoroutines(FrameEvent.LateUpdate);
 
 		try {
-			const physicsSteps = 2;
+			const physicsSteps = 1;
 			const dt = this.time.deltaTime / physicsSteps;
 			for (let i = 0; i < physicsSteps; i++) {
+				this.executeCoroutines(FrameEvent.PrePhysicsStep);
 				this.physics.step(dt);
-				this.executeCoroutines(FrameEvent.PhysicsStep);
+				this.executeCoroutines(FrameEvent.PostPhysicsStep);
 			}
 		}
 		catch (err) {

package/src/engine/engine_types.ts

@@ -1,6 +1,6 @@
-import { Camera, Color, Material, Object3D, Vector3 } from "three";
-import { Body, ContactEquation } from "cannon-es";
+import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
 import { RGBAColor } from "../engine-components/js-extensions/RGBAColor";
+import { CollisionDetectionMode, RigidbodyConstraints } from "./engine_physics.types";
 
 /** used to find data registered via gltf files e.g. find lightmaps for a Renderer component that were shipped inside a gltf */
 export declare type SourceIdentifier = string;
@@ -58,9 +58,10 @@ export interface IComponent {
     onDisable();
     onDestroy();
 
+    /** called for properties decorated with the @validate decorator */
+    onValidate?(property?: string);
+
     start?(): void;
-    // available update loop events:
-    // earlyUpdate, update, lateUpdate, onBeforeRender, onAfterRender
     earlyUpdate?(): void;
     update?(): void;
     lateUpdate?(): void;
@@ -69,17 +70,15 @@ export interface IComponent {
 
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
-    onCollisionExitRaw?(col: Collision);
     onCollisionStay?(col: Collision);
 
-    onTriggerEnter?(col: Collision);
-    onTriggerStay?(col: Collision);
-    onTriggerExit?(col: Collision);
-
-    __internalHandleCollision(col: Collision, isTriggerCollision: boolean);
-    __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean);
+    onTriggerEnter?(col: ICollider);
+    onTriggerStay?(col: ICollider);
+    onTriggerExit?(col: ICollider);
 
     get forward(): Vector3;
+    get worldPosition(): Vector3;
+    get worldQuaternion(): Quaternion;
 }
 
 
@@ -101,8 +100,8 @@ export declare interface ILight extends IComponent {
 }
 
 export declare interface ISharedMaterials {
-    [num:number] : Material;
-    get length() : number;
+    [num: number]: Material;
+    get length(): number;
 }
 
 export declare interface IRenderer extends IComponent {
@@ -110,6 +109,10 @@ export declare interface IRenderer extends IComponent {
     get sharedMaterials(): ISharedMaterials;
 }
 
+// export declare interface IPhysicsComponent extends IComponent {
+//     get type() : string;
+// }
+
 export declare interface ICollider extends IComponent {
     get isCollider();
     attachedRigidbody: IRigidbody | null;
@@ -117,67 +120,99 @@ export declare interface ICollider extends IComponent {
 }
 
 export declare interface IRigidbody extends IComponent {
-    initialize(): void;
-    body;
+    constraints: RigidbodyConstraints;
+    isKinematic: boolean;
+    mass: number;
+    drag: number;
+    angularDrag: number;
+    useGravity: boolean;
+    collisionDetectionMode: CollisionDetectionMode;
+
+    lockPositionX: boolean;
+    lockPositionY: boolean;
+    lockPositionZ: boolean;
+    lockRotationX: boolean;
+    lockRotationY: boolean;
+    lockRotationZ: boolean;
 }
 
 
+export const $physicsKey = Symbol("object");
 
 
+export declare type ICollisionContext = {
+    getCollider(obj: Object3D): ICollider;
+}
 
 
-
-export const $physicsKey = Symbol("object");
-
-export declare type CannonCollision = {
-    body: Body;
-    contact: ContactEquation;
-    target: Body;
-    type: string;
+export type Vec3 = {
+    x: number,
+    y: number,
+    z: number
 }
 
-export declare type ICollisionContext = {
-    getCollider(obj: Object3D): ICollider;
+export type Vec2 = {
+    x: number,
+    y: number
 }
 
-export class Collision {
+export class ContactPoint {
 
-    get __internalCollision(): CannonCollision {
-        return this.collision;
-    }
+    readonly localPoint: Vec3;
+    readonly distance: number;
+    readonly normal: Vec3;
 
-    get __internalInvertedSourceReceiver(): boolean {
-        return this.invert;
+    constructor(localPt: Vec3, dist: number, normal: Vec3) {
+        this.localPoint = localPt;
+        this.distance = dist;
+        this.normal = normal;
     }
 
-    private readonly invert: boolean;
-    private readonly collision: CannonCollision;
-    private readonly targetBody: Body;
-    private readonly context: ICollisionContext;
+}
 
-    readonly me: Object3D;
+/// all info in here must be readonly because the object is only created once per started collision
+export class Collision {
+
+    readonly contacts: ContactPoint[];
 
-    private _normal?: Vector3;
-    get normal(): Vector3 {
-        if (!this._normal) {
-            const vec = this.collision.contact.ni;
-            this._normal = new Vector3(vec.x, vec.y, vec.z);
-        }
-        return this._normal;
+    constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]) {
+        this.me = obj;
+        this._collider = otherCollider;
+        this._gameObject = otherCollider.gameObject;
+        this.contacts = contacts;
     }
 
-    private _collider?: ICollider;
+    readonly me: Object3D;
+    private _collider: ICollider;
+
+    /** the collider the collision happened with */
     get collider(): ICollider {
-        if (!this._collider) {
-            this._collider = this.context.getCollider(this.gameObject);
-        }
         return this._collider;
     }
 
+    /** the object the collision happened with */
+    private _gameObject: Object3D;
     get gameObject(): Object3D {
-        return this.targetBody[$physicsKey];
+        return this._gameObject;
+    }
+
+    /** the rigidbody we hit, null if none attached */
+    get rigidBody(): IRigidbody | null {
+        return this.collider?.attachedRigidbody;
     }
 
+    
+
+    // private _normal?: Vector3;
+    // get normal(): Vector3 {
+    //     if (!this._normal) {
+    //         const vec = this.collision.contact.ni;
+    //         this._normal = new Vector3(vec.x, vec.y, vec.z);
+    //     }
+    //     return this._normal;
+    // }
+
+
     // private _point?: Vector3;
     // get point(): Vector3 {
     //     if (!this._point) {
@@ -187,12 +222,4 @@ export class Collision {
     //     }
     //     return this._point;
     // }
-
-    constructor(obj: Object3D, collision: CannonCollision, context: ICollisionContext, invert: boolean = false) {
-        this.me = obj;
-        this.collision = collision;
-        this.context = context;
-        this.targetBody = invert ? collision.target : collision.body;
-        this.invert = invert;
-    }
 }

package/src/engine/engine_util_decorator.ts

@@ -0,0 +1,69 @@
+import { $isAssigningProperties } from "./engine_serialization_core";
+import { LogType, showBalloonMessage } from "./debug/debug";
+import { IComponent } from "./engine_types";
+
+
+declare type setter = (v: any) => void;
+declare type getter = () => any;
+
+/** create accessor callbacks for a field */
+export const validate = function (set?: setter, get?: getter) {
+    // "descriptor : undefined" prevents @validate() to be added to property getters or setters
+    return function (target: IComponent | any, propertyKey: string, descriptor?: undefined) {
+        createPropertyWrapper(target, propertyKey, descriptor, set, get);
+    }
+}
+
+
+function createPropertyWrapper(target: IComponent | any, propertyKey: string, descriptor?: PropertyDescriptor,
+    set?: setter,
+    get?: getter) {
+
+    if (!get && !set && !target.onValidate) return;
+
+    // this is not undefined when its a property getter or setter already and not just a field
+    // we currently only support validation of fields
+    if (descriptor !== undefined) {
+        console.error("Invalid usage of validate decorator. Only fields can be validated.", target, propertyKey, descriptor);
+        showBalloonMessage("Invalid usage of validate decorator. Only fields can be validated. Property: " + propertyKey, LogType.Error);
+        return;
+    }
+
+    if (target.__internalAwake) {
+        // this is the hidden key we save the original property to
+        const $prop = Symbol(propertyKey);
+        // save the original awake method
+        // we need to delay decoration until the object has been created
+        const awake = target.__internalAwake;
+        target.__internalAwake = function () {
+
+            // only build wrapper once per type
+            if (this[$prop] === undefined) {
+
+                // make sure the field is initialized in a hidden property
+                this[$prop] = this[propertyKey];
+
+                Object.defineProperty(this, propertyKey, {
+                    set: function (v) {
+                        if (this[$isAssigningProperties] === true) {
+                            this[$prop] = v;
+                        }
+                        else {
+                            set?.call(this, v);
+                            const oldValue = this[$prop];
+                            this[$prop] = v;
+                            this.onValidate?.call(this, propertyKey, oldValue);
+                        }
+                    },
+                    get: function () {
+                        get?.call(this);
+                        return this[$prop];
+                    },
+                });
+            }
+
+            // call the original awake method
+            awake.call(this);
+        };
+    }
+}

package/src/engine/engine_utils.ts

@@ -217,7 +217,7 @@ export function getPath(source: SourceIdentifier | undefined, uri: string): stri
 // }
 
 
-export type WriteCallback = (data: any) => void;
+export type WriteCallback = (data: any, prop: string) => void;
 
 export interface IWatch {
     subscribeWrite(callback: WriteCallback);
@@ -268,7 +268,7 @@ class WatchImpl implements IWatch {
         const setter = (value) => {
             object[this._wrapperProp] = value;
             for (const write of this.writeCallbacks) {
-                write(value);
+                write(value, this._prop);
             }
         }
         // add the wrapper to the object
@@ -321,7 +321,7 @@ export class Watch implements IWatch {
     apply() {
         for (const w of this._watches) {
             w.apply();
-        }   
+        }
     }
 
     revoke() {

package/src/engine/extensions/NEEDLE_gameobject_data.ts

@@ -66,6 +66,8 @@ export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
 
     private applyExtensionData(node: Object3D, ext: GameObjectData) {
         node.userData.layer = ext.layers;
+        node.layers.disableAll();
+        node.layers.set(ext.layers);
         node.userData.tag = ext.tag;
         node.userData.hideFlags = ext.hideFlags;
         node.userData.static = ext.static;

package/src/engine-components/Animation.ts

@@ -5,6 +5,7 @@ import { MixerEvent } from "./Animator";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { InstancingUtil } from "../engine/engine_instancing";
 import { Mathf } from "../engine/engine_math";
+import { Vec2 } from "../engine/engine_types";
 
 export declare class PlayOptions {
     fadeDuration?: number;
@@ -13,8 +14,8 @@ export declare class PlayOptions {
     startTime?: number;
     endTime?: number;
     clampWhenFinished?: boolean;
-    minMaxSpeed?: Vector2;
-    minMaxOffsetNormalized?: Vector2;
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
 }
 
 export class Animation extends Behaviour {
@@ -24,11 +25,8 @@ export class Animation extends Behaviour {
     @serializeable()
     randomStartTime: boolean = true;
 
-    @serializeable(Vector2)
-    minMaxSpeed?: Vector2;
-
-    @serializeable(Vector2)
-    minMaxOffsetNormalized?: Vector2;
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
 
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
     get clip(): AnimationClip | null {
@@ -114,6 +112,14 @@ export class Animation extends Behaviour {
         return this.actions?.find(a => a.getClip().name === name);
     }
 
+    get isPlaying() {
+        for (let i = 0; i < this._currentActions.length; i++) {
+            if (this._currentActions[i].isRunning())
+                return true;
+        }
+        return false;
+    }
+
     play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void {
         this.init();
         if (!this.mixer) return;
@@ -129,9 +135,9 @@ export class Animation extends Behaviour {
             console.error("Could not find clip", clipOrNumber)
             return;
         }
-        if(!options) options = {};
-        if(!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
-        if(!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
+        if (!options) options = {};
+        if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
+        if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);
@@ -163,8 +169,8 @@ export class Animation extends Behaviour {
         action.time = 0;
         action.timeScale = 1;
         const clip = action.getClip();
-        if(options?.minMaxOffsetNormalized) action.time = Mathf.lerp(options.minMaxOffsetNormalized.x, options.minMaxOffsetNormalized.y, Math.random()) * clip.duration;
-        if(options?.minMaxSpeed) action.timeScale = Mathf.lerp(options.minMaxSpeed.x, options.minMaxSpeed.y, Math.random());
+        if (options?.minMaxOffsetNormalized) action.time = Mathf.lerp(options.minMaxOffsetNormalized.x, options.minMaxOffsetNormalized.y, Math.random()) * clip.duration;
+        if (options?.minMaxSpeed) action.timeScale = Mathf.lerp(options.minMaxSpeed.x, options.minMaxSpeed.y, Math.random());
         if (options?.clampWhenFinished) action.clampWhenFinished = true;
         if (options?.startTime !== undefined) action.time = options.startTime;
 

package/src/engine-components/AnimatorController.ts

@@ -218,7 +218,7 @@ export class AnimatorController {
             if (!allConditionsAreMet) continue;
 
             if (debug && allConditionsAreMet) {
-                console.log("All conditions are met", transition);
+                // console.log("All conditions are met", transition);
             }
 
             // disable triggers
@@ -232,16 +232,16 @@ export class AnimatorController {
             if (action) {
                 const dur = state.motion.clip!.duration;
                 const normalizedTime = dur <= 0 ? 1 : action.time / dur;
-                if (!transition.hasExitTime
-                    || (normalizedTime >= transition.exitTime && action.time >= action.getClip().duration
-                    )
-                ) {
+                const makeTransition = transition.hasExitTime ? normalizedTime >= transition.exitTime : true;
+                // console.log(state.name, makeTransition, transition.hasExitTime, normalizedTime, transition.exitTime)
+                if (makeTransition) {
                     // if (transition.hasExitTime && transition.exitTime >= .9999) 
                     action.clampWhenFinished = true;
                     // else action.clampWhenFinished = false;
-                    if (debug) {
-                        console.log("transition to " + transition.destinationState, transition);
-                        console.log(action.time, transition.exitTime);
+                    if (debug) 
+                    {
+                        console.log("transition to " + transition.destinationState, transition, normalizedTime, transition.exitTime, transition.hasExitTime);
+                        // console.log(action.time, transition.exitTime);
                     }
                     this.transitionTo(transition.destinationState as State, transition.duration, transition.offset);
                     // use the first transition that matches all conditions and make the transition as soon as in range
@@ -252,7 +252,7 @@ export class AnimatorController {
                 this.transitionTo(transition.destinationState as State, transition.duration, transition.offset);
                 return;
             }
-            break;
+            // if none of the transitions can be made continue searching for another transition meeting the conditions
         }
 
         let didTriggerLooping = false;
@@ -376,7 +376,13 @@ export class AnimatorController {
     }
 
     private createAction(clip: AnimationClip) {
-        this._mixer.uncacheClip(clip);
+
+        // uncache clip causes issues when multiple states use the same clip
+        // this._mixer.uncacheClip(clip);
+        // instead only uncache the action when one already exists to make sure
+        // we get unique actions per state
+        const existing = this._mixer.existingAction(clip);
+        if (existing) this._mixer.uncacheAction(clip, this.animator?.gameObject);
 
         if (this.animator?.applyRootMotion) {
             if (!this.rootMotionHandler) {
@@ -387,7 +393,6 @@ export class AnimatorController {
             return this.rootMotionHandler.createClip(this._mixer, root, clip);
         }
         else {
-
             const action = this._mixer.clipAction(clip);
             return action;
         }

package/src/engine-components/BoxHelperComponent.ts

@@ -55,6 +55,7 @@ export class BoxHelperComponent extends Behaviour {
         // this.tp.applyMatrix4(obj.matrixWorld);
         // console.log(this.tp);
         // console.log(this.box?.min, this.box?.max, this.tp.min, this.tp.max);
+        this.updateBox();
         return this.box?.intersectsBox(BoxHelperComponent.testBox);
     }