Needle Engine 3.32.6-alpha

Files changed (6) hide show

src/engine/engine_addressables.ts +17 -19
src/engine/engine_gameobject.ts +24 -2
src/engine/engine_networking_instantiate.ts +3 -3
src/engine-components/ui/EventSystem.ts +16 -3
src/engine-components/timeline/PlayableDirector.ts +1 -1
src/engine-components/timeline/TimelineTracks.ts +51 -14

src/engine/engine_addressables.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import { getParam, resolveUrl } from "../engine/engine_utils.js";
-import { SerializationContext, TypeSerializer } from "./engine_serialization_core.js";
+import { deepClone, getParam, resolveUrl } from "../engine/engine_utils.js";
+import { SerializationContext, TypeSerializer, assign } from "./engine_serialization_core.js";
 import { Context } from "./engine_setup.js";
 import { Group, Object3D, Texture, TextureLoader } from "three";
 import { processNewScripts } from "./engine_mainloop_utils.js";
@@ -272,32 +272,30 @@
         }
     }
-    private async onInstantiate(parent?: Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
+    private async onInstantiate(opts?: Object3D | IInstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
         const context = Context.Current;
+        // clone the instantiate options immediately
+        // in case the user is not awaiting this call and already modifying the options
+        const options = new InstantiateOptions();
+        if (opts instanceof Object3D) {
+            options.parent = opts;
+        }
+        else if (opts) {
+            options.cloneAssign(opts);
+        }
+        if (!options.parent) options.parent = context.scene;
+        // ensure the asset is loaded
         if (this.mustLoad) {
             await this.loadAssetAsync();
         }
         if (debug)
-            console.log("Instantiate", this.uri, "parent:", parent);
+            console.log("Instantiate", this.uri, "parent:", opts);
         if (this.asset) {
             if (debug) console.log("Add to scene", this.asset);
-            let options = parent instanceof InstantiateOptions ? parent : null;
-            if (!options) {
-                options = new InstantiateOptions();
-            }
-            if (typeof parent === "object") {
-                if (parent instanceof Object3D) {
-                    options.parent = parent;
-                }
-                else {
-                    Object.assign(options, parent);
-                }
-            }
-            if (!options.parent) options.parent = context.scene;
             let count = AssetReference.currentlyInstantiating.get(this.uri);
             // allow up to 10000 instantiations of the same prefab in the same frame
             if (count !== undefined && count >= 10000) {

src/engine/engine_gameobject.ts CHANGED Viewed

@@ -51,6 +51,27 @@
     scale?: Vector3 | undefined;
     visible?: boolean | undefined;
     context?: Context | undefined;
+    clone(){
+        const clone = new InstantiateOptions();
+        clone.idProvider = this.idProvider;
+        clone.parent = this.parent;
+        clone.keepWorldPosition = this.keepWorldPosition;
+        clone.position = this.position?.clone();
+        clone.rotation = this.rotation?.clone();
+        clone.scale = this.scale?.clone();
+        return clone;
+    }
+    /** Copy fields from another object, clone field references */
+    cloneAssign(other: InstantiateOptions | IInstantiateOptions){
+        this.idProvider = other.idProvider;
+        this.parent = other.parent;
+        this.keepWorldPosition = other.keepWorldPosition;
+        this.position = other.position?.clone();
+        this.rotation = other.rotation?.clone();
+        this.scale = other.scale?.clone();
+    }
 }
@@ -245,7 +266,7 @@
     clone: Object3D;
 }
-export function instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+export function instantiate(instance: GameObject | Object3D | null, opts: IInstantiateOptions | null = null): GameObject | null {
     if (instance === null) return null;
     let options: InstantiateOptions | null = null;
@@ -264,6 +285,7 @@
             // }
         }
     }
+    console.log(options?.position)
     let context = Context.Current;
     if (options?.context) context = options.context;
@@ -319,7 +341,7 @@
 function internalInstantiate(
-    context: Context, instance: GameObject | Object3D, opts: InstantiateOptions | null,
+    context: Context, instance: GameObject | Object3D, opts: IInstantiateOptions | InstantiateOptions | null,
     componentsList: Array<Component>,
     newGameObjectsMap: { [key: string]: NewGameObjectReferenceInfo },
     skinnedMeshesMap: { [key: string]: NewGameObjectReferenceInfo }

src/engine/engine_networking_instantiate.ts CHANGED Viewed

@@ -11,7 +11,7 @@
 import type { UIDProvider } from "./engine_types.js";
 import type { IModel } from "./engine_networking_types.js";
 import { SendQueue } from "./engine_networking_types.js";
-import { destroy, findByGuid, instantiate } from "./engine_gameobject.js";
+import { IInstantiateOptions, destroy, findByGuid, instantiate } from "./engine_gameobject.js";
 import { Object3D } from "three";
 import { InstantiateOptions } from "./engine_gameobject.js";
 import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry.js";
@@ -185,7 +185,7 @@
     }
 }
-export function syncInstantiate(object: GameObject | Object3D, opts: InstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
+export function syncInstantiate(object: GameObject | Object3D, opts: IInstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
     const obj: GameObject = object as GameObject;
@@ -290,7 +290,7 @@
 }
-function instantiateSeeded(obj: GameObject, opts: InstantiateOptions | null): { instance: GameObject | null, seed: number } {
+function instantiateSeeded(obj: GameObject, opts: IInstantiateOptions | null): { instance: GameObject | null, seed: number } {
     const seed = generateSeed();
     const options = opts ?? new InstantiateOptions();
     options.idProvider = new InstantiateIdProvider(seed);

src/engine-components/ui/EventSystem.ts CHANGED Viewed

@@ -488,9 +488,22 @@
         const pressedEvent = this.pressedByID.get(args.pointerId);
         const hoveredObjectChanged = prevHovering !== object;
-        const posLastFrame = this.context.input.getPointerPositionLastFrame(args.pointerId!)!;
-        const posThisFrame = this.context.input.getPointerPosition(args.pointerId!)!;
-        const isMoving = posLastFrame && !Mathf.approximately(posLastFrame, posThisFrame);
+        // TODO: should we not move this check up before we even raycast for "pointerMove" events? We dont need to do any processing if the pointer didnt move
+        let isMoving = true;
+        switch (args.event.pointerType) {
+            case "mouse":
+            case "touch":
+                const posLastFrame = this.context.input.getPointerPositionLastFrame(args.pointerId!)!;
+                const posThisFrame = this.context.input.getPointerPosition(args.pointerId!)!;
+                isMoving = posLastFrame && !Mathf.approximately(posLastFrame, posThisFrame);
+                break;
+            case "controller":
+            case "hand":
+                // for hands and controller we assume they are never totally still (except for simulated environments)
+                // we might want to add a threshold here (e.g. if a user holds their hand very still or controller)
+                // so maybe check the angle every frame?
+                break;
+        }
         this.propagate(object, args, (behaviour) => {
             const comp = behaviour as any;

src/engine-components/timeline/PlayableDirector.ts CHANGED Viewed

@@ -164,9 +164,9 @@
         if (!this.isValid()) return;
         const pauseChanged = this._isPaused == true;
         this._isPaused = false;
-        if (pauseChanged) this.invokePauseChangedMethodsOnTracks();
         if (this._isPlaying) return;
         this._isPlaying = true;
+        if (pauseChanged) this.invokePauseChangedMethodsOnTracks();
         if (this.waitForAudio) {
             // Make sure audio tracks have loaded at the current time
             const promises: Array<Promise<any>> = [];

src/engine-components/timeline/TimelineTracks.ts CHANGED Viewed

@@ -563,14 +563,16 @@
 const muteAudioTracks = getParam("mutetimeline");
+declare type AudioClipModel = Models.ClipModel & { _didTriggerPlay: boolean };
 export class AudioTrackHandler extends TrackHandler {
-    models: Array<Models.ClipModel> = [];
+    models: Array<AudioClipModel> = [];
     listener!: AudioListener;
     audio: Array<Audio> = [];
     audioContextTimeOffset: Array<number> = [];
     lastTime: number = 0;
-    audioSource?:AudioSource;
+    audioSource?: AudioSource;
     private _audioLoader: AudioLoader | null = null;
@@ -591,7 +593,9 @@
     addModel(model: Models.ClipModel) {
         const audio = new Audio(this.listener as any);
         this.audio.push(audio);
-        this.models.push(model);
+        const audioClipModel = model as AudioClipModel;
+        audioClipModel._didTriggerPlay = false;
+        this.models.push(audioClipModel);
     }
     onDisable() {
@@ -599,6 +603,9 @@
             if (audio.isPlaying)
                 audio.stop();
         }
+        for (const model of this.models) {
+            model._didTriggerPlay = false;
+        }
     }
     onDestroy() {
@@ -626,8 +633,23 @@
             if (audio?.isPlaying)
                 audio.stop();
         }
+        for (const model of this.models) {
+            model._didTriggerPlay = false;
+        }
     }
+    private _playableDirectorResumed = false;
+    onPauseChanged() {
+        // if the timeline gets paused we stop all audio clips
+        // we dont reset the triggerPlay here (this will automatically reset when the timeline start evaluating again)
+        for (let i = 0; i < this.audio.length; i++) {
+            const audio = this.audio[i];
+            if (audio?.isPlaying)
+                audio.stop();
+        }
+        this._playableDirectorResumed = this.director.isPlaying;
+    }
     evaluate(time: number) {
         if (muteAudioTracks) return;
         if (this.track.muted) return;
@@ -636,6 +658,8 @@
             return;
         }
         const isMuted = this.director.context.application.muted;
+        const resumePlay = this._playableDirectorResumed;
+        this._playableDirectorResumed = false;
         // this is just so that we dont hear the very first beat when the audio starts but is muted
         // if we dont add a delay we hear a little bit of the audio before it shuts down
         // MAYBE instead of doing it like this we should connect a custom audio node (or disconnect the output node?)
@@ -653,15 +677,24 @@
             audio.playbackRate = this.director.context.time.timeScale * this.director.speed;
             audio.loop = asset.loop;
             if (time >= model.start && time <= model.end && time < this.director.duration) {
-                if (this.director.isPlaying == false) {
-                    if (audio.isPlaying)
-                        audio.stop();
-                    if (this.lastTime === time) continue;
+                if (!audio.isPlaying || !this.director.isPlaying) {
+                    // if the timeline is paused we trigger the audio clip once when the model is entered
+                    // we dont playback the audio clip if we scroll back in time
+                    // this is to support audioclip playback when using timeline with manual scrolling (scrollytelling)
+                    if (resumePlay || (!model._didTriggerPlay && this.lastTime < time)) {
+                        // we don't want to clip in the audio if it's a very short clip
+                        const clipDuration = model.duration * model.timeScale;
+                        if (clipDuration > .3)
+                            audio.offset = model.clipIn + (time - model.start) * model.timeScale;
+                        else audio.offset = 0;
+                        if (debug) console.log("Timeline Audio (" + this.track.name + ") play with offset " + audio.offset + " - " + model.asset.clip);
+                        audio.play(playTimeOffset);
+                        model._didTriggerPlay = true;
+                    }
+                    else {
+                        // do nothing...
+                    }
                 }
-                else if (!audio.isPlaying) {
-                    audio.offset = model.clipIn + (time - model.start) * model.timeScale;
-                    audio.play(playTimeOffset);
-                }
                 else {
                     const targetOffset = model.clipIn + (time - model.start) * model.timeScale;
                     // seems it's non-trivial to get the right time from audio sources;
@@ -677,7 +710,7 @@
                 }
                 let vol = asset.volume as number;
-                if(this.track.volume !== undefined)
+                if (this.track.volume !== undefined)
                     vol *= this.track.volume;
                 if (isMuted) vol = 0;
@@ -692,8 +725,12 @@
                 audio.setVolume(vol * this.director.weight);
             }
             else {
-                if (audio.isPlaying)
-                    audio.stop();
+                model._didTriggerPlay = false;
+                if (this.director.isPlaying) {
+                    if (audio.isPlaying) {
+                        audio.stop();
+                    }
+                }
             }
         }
         this.lastTime = time;