Needle Engine 3.45.2-beta

Files changed (6) hide show

src/engine-components/Animation.ts +161 -77
src/engine-components/Component.ts +6 -0
src/engine/engine_context.ts +1 -1
src/engine/engine_input.ts +14 -7
src/engine/xr/NeedleXRSession.ts +1 -1
src/engine-components/Renderer.ts +4 -0

src/engine-components/Animation.ts CHANGED Viewed

@@ -9,17 +9,52 @@
 const debug = getParam("debuganimation");
-export declare class PlayOptions {
+export declare type PlayOptions = {
+    /**
+     * The fade duration in seconds for the action to fade in and other actions to fade out (if exclusive is enabled)
+     */
     fadeDuration?: number;
+    /**
+     * If true, the animation will loop
+     */
     loop?: boolean;
+    /**
+     * If true, will stop all other animations before playing this one
+     * @default true
+     */
     exclusive?: boolean;
+    /**
+     * The animation start time in seconds
+     */
     startTime?: number;
+    /**
+     * The animation end time in seconds
+     */
     endTime?: number;
+    /**
+     * If true, the animation will clamp when finished
+     */
     clampWhenFinished?: boolean;
+    /**
+     * Animation playback speed. This is a multiplier to the animation speed
+     * @default 1
+     */
+    speed?: number;
+    /**
+     * Animation playback speed range. This will override speed
+     * @default undefined
+     */
     minMaxSpeed?: Vec2;
+    /**
+     * The normalized offset to start the animation at. This will override startTime
+     * @default undefined
+     */
     minMaxOffsetNormalized?: Vec2;
 }
+declare type AnimationIdentifier = AnimationClip | number | string | undefined;
 class Vec2 { x!: number; y!: number }
 /**
@@ -35,6 +70,7 @@
     @serializable()
     playAutomatically: boolean = true;
     @serializable()
     randomStartTime: boolean = true;
@@ -46,13 +82,22 @@
     @serializable()
     loop: boolean = true;
+    /**
+     * If true, the animation will clamp when finished
+     */
     @serializable()
     clampWhenFinished: boolean = false;
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
+    /**
+     * Get the first animation clip in the animations array
+     */
     get clip(): AnimationClip | null {
         return this.animations?.length ? this.animations[0] : null;
     }
+    /**
+     * Set the first animation clip in the animations array
+     */
     set clip(val: AnimationClip | null) {
         if (!this.__didAwake) {
             if (debug) console.warn("Assign clip during serialization", val);
@@ -88,20 +133,7 @@
     get animations(): AnimationClip[] {
         return this.gameObject.animations || this._tempAnimationsArray || [];
     }
-    /**
-     * @deprecated Currently unsupported
-     */
-    get currentAction(): AnimationAction | null {
-        return this._currentActions[0];
-    }
-    /**
-     * @deprecated Currently unsupported
-     */
-    get currentActions(): AnimationAction[] {
-        return this._currentActions;
-    }
     private mixer: AnimationMixer | undefined = undefined;
     get actions(): Array<AnimationAction> {
         return this._actions;
@@ -111,11 +143,9 @@
     }
     private _actions: Array<AnimationAction> = [];
-    // private _currentAction: AnimationAction | null = null;
-    private _currentActions: AnimationAction[] = [];
     private _handles: AnimationHandle[] = [];
+    /** @internal */
     awake() {
         if (debug) console.log("Animation Awake", this.name, this);
         if (this._tempAnimationsArray) {
@@ -130,45 +160,43 @@
         if (this.playAutomatically)
             this.init();
     }
+    /** @internal */
     onEnable(): void {
-        if (this.playAutomatically && this.animations?.length > 0 && this.currentActions.length <= 0) {
-            const index = Math.floor(Math.random() * this.actions.length);
-            this.play(index);
+        if (this.playAutomatically && this.animations?.length > 0) {
+            const index = Math.floor(Math.random() * this.animations.length);
+            const animation = this.animations[index];
+            this.play(index, {
+                exclusive: true,
+                fadeDuration: 0,
+                startTime: this.randomStartTime ? Math.random() * animation.duration : 0,
+                loop: this.loop,
+                clampWhenFinished: this.clampWhenFinished
+            });
         }
     }
+    /** @internal */
+    update() {
+        if (!this.mixer) return;
+        this.mixer.update(this.context.time.deltaTime);
+    }
+    /** @internal */
     onDisable(): void {
         if (this.mixer) {
             this.mixer.stopAllAction();
             this.mixer = undefined;
         }
     }
+    /** @internal */
     onDestroy(): void {
         this.context.animations.unregisterAnimationMixer(this.mixer);
     }
-    start() {
-        if (this.randomStartTime && this.currentAction)
-            this.currentAction.time = Math.random() * this.currentAction.getClip().duration;
+    /** Get an animation action by the animation clip name */
+    getAction(name: string): AnimationAction | null {
+        return this.actions?.find(a => a.getClip().name === name) || null;
     }
-    update() {
-        if (!this.mixer) return;
-        this.mixer.update(this.context.time.deltaTime);
-        // this is now handled via matrix auto update
-        // for (const handle of this._handles) {
-        //     handle._update();
-        // }
-        // if (this._handles?.length > 0)
-        //     InstancingUtil.markDirty(this.gameObject);
-    }
-    getAction(name: string): AnimationAction | undefined | null {
-        return this.actions?.find(a => a.getClip().name === name);
-    }
+    /** Is any animation playing? */
     get isPlaying() {
         for (let i = 0; i < this.actions.length; i++) {
             if (this.actions[i].isRunning())
@@ -177,7 +205,54 @@
         return false;
     }
-    play(clipOrNumber: AnimationClip | number | string | undefined = 0, options?: PlayOptions): Promise<AnimationAction> | void {
+    /** Stops all currently playing animations */
+    stopAll(opts?: Pick<PlayOptions, "fadeDuration">): void {
+        for (const act of this.actions) {
+            if (opts?.fadeDuration) {
+                act.fadeOut(opts.fadeDuration);
+            }
+            else {
+                act.stop();
+            }
+        }
+    }
+    /**
+     * Stops a specific animation clip or index. If clip is undefined then all animations will be stopped
+     */
+    stop(clip?: AnimationIdentifier, opts?: Pick<PlayOptions, "fadeDuration">): void {
+        if (clip === undefined) {
+            this.stopAll();
+            return;
+        }
+        else if (typeof clip === "number") {
+            if (clip >= this.animations.length) {
+                if (debug) console.log("No animation at index", clip)
+                return;
+            }
+            clip = this.animations[clip];
+        }
+        else if (typeof clip === "string") {
+            clip = this.animations.find(a => a.name === clip);
+        }
+        if (!clip) {
+            console.error("Could not find clip", clip)
+            return;
+        }
+        const act = this.actions.find(a => a.getClip() === clip);
+        if (!act) {
+            console.error("Could not find action", clip)
+            return;
+        }
+        if (opts?.fadeDuration) {
+            act.fadeOut(opts.fadeDuration);
+        }
+        else {
+            act.stop();
+        }
+    }
+    play(clipOrNumber: AnimationIdentifier = 0, options?: PlayOptions): Promise<AnimationAction> | void {
         if (debug) console.log("PLAY", clipOrNumber)
         this.init();
         if (!this.mixer) {
@@ -200,11 +275,9 @@
             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.loop === undefined) options.loop = this.loop;
-        if (options.clampWhenFinished === undefined) options.clampWhenFinished = this.clampWhenFinished;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);
@@ -219,45 +292,63 @@
         return this.internalOnPlay(act, options);
     }
-    internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction> {
-        var prev = this.currentAction;
+    private internalOnPlay(action: AnimationAction, options: PlayOptions): Promise<AnimationAction> {
+        var prev = this.actions.find(a => a === action);
         if (prev === action && prev.isRunning() && prev.time < prev.getClip().duration) {
             const handle = this.tryFindHandle(action);
-            if (handle) return handle.getPromise();
+            if (handle) return handle.waitForFinish();
         }
+        // Assign defaults
+        if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
+        if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
+        if (options.loop === undefined) options.loop = this.loop;
+        if (options.clampWhenFinished === undefined) options.clampWhenFinished = this.clampWhenFinished;
+        // Reset currently running animations
         const stopOther = options?.exclusive ?? true;
+        if (stopOther) {
+            this.stopAll(options);
+        }
         if (options?.fadeDuration) {
-            if (stopOther)
-                prev?.fadeOut(options.fadeDuration);
             action.fadeIn(options.fadeDuration);
         }
+        action.enabled = true;
+        // Apply start time
+        if (options?.minMaxOffsetNormalized) {
+            const clip = action.getClip();
+            action.time = Mathf.lerp(options.minMaxOffsetNormalized.x, options.minMaxOffsetNormalized.y, Math.random()) * clip.duration;
+        }
+        else if (options?.startTime != undefined) {
+            action.time = options.startTime;
+        }
+        // Apply speed
+        if (options?.minMaxSpeed) {
+            action.timeScale = Mathf.lerp(options.minMaxSpeed.x, options.minMaxSpeed.y, Math.random());
+        }
         else {
-            if (stopOther)
-                prev?.stop();
+            action.timeScale = options?.speed ?? 1;
         }
-        action.reset();
-        action.enabled = true;
-        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?.clampWhenFinished) action.clampWhenFinished = true;
-        if (options?.startTime !== undefined) action.time = options.startTime;
-        if (options?.loop !== undefined)
+        // Apply looping
+        if (options?.loop != undefined) {
             action.loop = options.loop ? LoopRepeat : LoopOnce;
+        }
         else action.loop = LoopOnce;
+        if (options?.clampWhenFinished) {
+            action.clampWhenFinished = true;
+        }
         action.play();
-        if (debug)
-            console.log("PLAY", action.getClip().name, action)
+        if (debug) console.log("PLAY", action.getClip().name, action)
         const handle = new AnimationHandle(action, this.mixer!, options, _ => {
             this._handles.splice(this._handles.indexOf(handle), 1);
-            // console.log(this._handles);
         });
         this._handles.push(handle);
-        return handle.getPromise();
+        return handle.waitForFinish();
     }
     private tryFindHandle(action: AnimationAction): AnimationHandle | undefined {
@@ -295,44 +386,37 @@
     private _finishedCallback?: any;
     private _resolvedOrRejectedCallback?: (AnimationHandle) => void;
-    constructor(action: AnimationAction, mixer: AnimationMixer, opts?: PlayOptions, cb?: (handle: AnimationHandle) => void) {
+    constructor(action: AnimationAction, mixer: AnimationMixer, opts?: PlayOptions, onDone?: (handle: AnimationHandle) => void) {
         this.action = action;
         this.mixer = mixer;
-        this._resolvedOrRejectedCallback = cb;
+        this._resolvedOrRejectedCallback = onDone;
         this._options = opts;
     }
-    getPromise(): Promise<AnimationAction> {
+    waitForFinish(): Promise<AnimationAction> {
         if (this.promise) return this.promise;
         this.promise = new Promise((res, rej) => {
             this._resolveCallback = res;
             this._rejectCallback = rej;
             this.resolve = this.onResolve.bind(this);
             this.reject = this.onReject.bind(this);
         });
         this._loopCallback = this.onLoop.bind(this);
         this._finishedCallback = this.onFinished.bind(this);
         this.mixer.addEventListener('loop', this._loopCallback);
         this.mixer.addEventListener('finished', this._finishedCallback);
         return this.promise;
     }
     _update() {
         if (!this._options) return;
         if (this._options.endTime !== undefined && this.action.time > this._options.endTime) {
             if (this._options.loop === true) {
                 this.action.time = this._options.startTime ?? 0;
             }
             else {
-                // this.action.stop();
                 this.action.time = this._options.endTime;
                 this.action.timeScale = 0;
-                // if (!this._options.clampWhenFinished)
-                //     this.action.stop();
                 this.onResolve();
             }
         }

src/engine-components/Component.ts CHANGED Viewed

@@ -388,6 +388,12 @@
     get static() {
         return this.gameObject?.userData.static;
     }
+    set static(value: boolean) {
+        if (this.gameObject) {
+            if (!this.gameObject.userData) this.gameObject.userData = {}
+            this.gameObject.userData.static = value;
+        }
+    }
     get hideFlags(): HideFlags {
         return this.gameObject?.userData.hideFlags;
     }

src/engine/engine_context.ts CHANGED Viewed

@@ -137,7 +137,7 @@
  */
 export class Context implements IContext {
-	private static _defaultTargetFramerate: { value?: number, toString?() } = { value: 60, toString() { return this.value; } }
+	private static _defaultTargetFramerate: { value?: number, toString?() } = { value: 90, toString() { return this.value; } }
 	/** When a new context is created this is the framerate that will be used by default */
 	static get DefaultTargetFrameRate(): number | undefined {
 		return Context._defaultTargetFramerate.value;

src/engine/engine_input.ts CHANGED Viewed

@@ -854,6 +854,9 @@
     private onPointerDown = (evt: PointerEvent) => {
         if (this.context.isInAR) return;
         if (this.canReceiveInput(evt) === false) return;
+        if (evt.target instanceof HTMLElement) {
+            evt.target.setPointerCapture(evt.pointerId);
+        }
         const id = this.getPointerId(evt);
         if (debug) showBalloonMessage(`pointer down #${id}, identifier:${evt.pointerId}`);
         const space = this.getAndUpdateSpatialObjectForScreenPosition(id, evt.clientX, evt.clientY);
@@ -862,7 +865,8 @@
     }
     private onPointerMove = (evt: PointerEvent) => {
         if (this.context.isInAR) return;
-        if (this.canReceiveInput(evt) === false) return;
+        // We want to keep receiving move events until pointerUp and not stop handling events just because we're hovering over *some* HTML element
+        // if (this.canReceiveInput(evt) === false) return;
         let button = evt.button;
         if (evt.pointerType === "mouse") {
             const pressedButton = this.getFirstPressedButtonForPointer(0);
@@ -876,8 +880,17 @@
         const ne = new NEPointerEvent(InputEvents.PointerMove, evt, { origin: this, mode: "screen", deviceIndex: 0, pointerId: id, button: button, clientX: evt.clientX, clientY: evt.clientY, pointerType: evt.pointerType as PointerTypeNames, buttonName: this.getButtonName(evt), device: space, pressure: evt.pressure });
         this.onMove(ne);
     }
+    private onPointerCancel = (evt: PointerEvent) => {
+        if (this.context.isInAR) return;
+        if (debug) console.log("Pointer cancel", evt);
+        // we treat this as an up event for now to make sure we don't have any pointers stuck in a pressed state etc. Technically we dont want to invoke a up event for cancels...
+        this.onPointerUp(evt);
+    }
     private onPointerUp = (evt: PointerEvent) => {
         if (this.context.isInAR) return;
+        if (evt.target instanceof HTMLElement) {
+            evt.target.releasePointerCapture(evt.pointerId);
+        }
         // the pointer up event should always be handled
         // if (this.canReceiveInput(evt) === false) return;
         const id = this.getPointerId(evt);
@@ -887,12 +900,6 @@
         this._pointerIds[id] = -1;
         if (debug) console.log("ID=" + id, "PointerId=" + evt.pointerId, "ALL:", [...this._pointerIds]);
     }
-    private onPointerCancel = (evt: PointerEvent) => {
-        if (this.context.isInAR) return;
-        if (debug) console.log("Pointer cancel", evt);
-        // we treat this as an up event for now to make sure we don't have any pointers stuck in a pressed state etc. Technically we dont want to invoke a up event for cancels...
-        this.onPointerUp(evt);
-    }
     private getPointerId(evt: PointerEvent, button?: number): number {
         if (evt.pointerType === "mouse") return 0 + (button ?? evt.button);

src/engine/xr/NeedleXRSession.ts CHANGED Viewed

@@ -842,7 +842,7 @@
         // handle controller and input source changes changes
         this.session.addEventListener('end', this.onEnd);
         // handle input sources change
-        this.session.addEventListener("inputsourceschange", (evt: XRInputSourceChangeEvent) => {
+        this.session.addEventListener("inputsourceschange", (evt: XRInputSourcesChangeEvent) => {
             // handle removed controllers
             for (const removedInputSource of evt.removed) {
                 this.disconnectInputSource(removedInputSource);

src/engine-components/Renderer.ts CHANGED Viewed

@@ -718,6 +718,10 @@
         if (this.reflectionProbeUsage !== ReflectionProbeUsage.Off && this._reflectionProbe) {
             this._reflectionProbe.onUnset(this);
         }
+        if (this.static && this.gameObject.matrixAutoUpdate) {
+            this.gameObject.matrixAutoUpdate = false;
+        }
     }
     /** Applies stencil settings for this renderer's objects (if stencil settings are available) */