@needle-tools/engine 3.2.0-alpha → 3.2.2-alpha

package/src/engine-components/SceneSwitcher.ts

@@ -7,6 +7,8 @@ import { getParam, isMobileDevice, setParamWithoutReload } from "../engine/engin
 import { serializable } from "../engine/engine_serialization";
 import { Behaviour, GameObject } from "./Component";
 
+const debug = getParam("debugsceneswitcher");
+
 const ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME = "scene";
 
 ContextRegistry.registerCallback(ContextEvent.ContextRegistered, _ => {
@@ -25,6 +27,9 @@ export class SceneSwitcher extends Behaviour {
     @serializable()
     queryParameterName: string = "scene";
 
+    @serializable()
+    clamp: boolean = true;
+
     /** when enabled the new scene is pushed to the browser navigation history, only works with a valid query parameter set */
     @serializable()
     useHistory: boolean = true;
@@ -37,18 +42,21 @@ export class SceneSwitcher extends Behaviour {
     @serializable()
     useSwipe: boolean = true;
 
+
     private _currentIndex: number = -1;
     private _currentScene: AssetReference | undefined = undefined;
     private _engineElementOverserver: MutationObserver | undefined = undefined;
 
-    start() {
-        if (!this.tryLoadFromQueryParam()) {
+    async start() {
+        if (this._currentIndex === -1 && !await this.tryLoadFromQueryParam()) {
             const value = this.context.domElement.getAttribute(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME);
             // let locked = this.lock;
             try {
                 // this.lock = false;
-                if (value === null || !this.trySelectSceneFromValue(value))
-                    this.select(0);
+                if (value === null || !await this.trySelectSceneFromValue(value)) {
+                    if (this._currentIndex === -1)
+                        this.select(0);
+                }
             }
             finally {
                 // this.lock = locked;
@@ -146,18 +154,25 @@ export class SceneSwitcher extends Behaviour {
         }
     }
 
-    selectNext() {
+    selectNext(): Promise<boolean> {
         return this.select(this._currentIndex + 1);
     }
 
-    selectPrev() {
+    selectPrev(): Promise<boolean> {
         return this.select(this._currentIndex - 1);
     }
 
-    select(index: number) {
+    select(index: number): Promise<boolean> {
+        if (debug) console.log("select", index)
         if (!this.scenes?.length) return couldNotLoadScenePromise;
-        if (index < 0) index = this.scenes.length - 1;
-        if (index >= this.scenes.length) index = 0;
+        if (index < 0) {
+            if (this.clamp) return couldNotLoadScenePromise;
+            index = this.scenes.length - 1;
+        }
+        else if (index >= this.scenes.length) {
+            if (this.clamp) return couldNotLoadScenePromise;
+            index = 0;
+        }
         const scene = this.scenes[index];
         return this.switchScene(scene);
     }
@@ -165,12 +180,15 @@ export class SceneSwitcher extends Behaviour {
     async switchScene(scene: AssetReference): Promise<boolean> {
         if (scene === this._currentScene) return true;
         if (this._currentScene)
-            GameObject.remove(this._currentScene.asset);
+            this._currentScene.unload();
         const index = this._currentIndex = this.scenes?.indexOf(scene) ?? -1;
         this._currentScene = scene;
         try {
             await scene.loadAssetAsync();
-            if (!scene.asset) return false;
+            if (!scene.asset) {
+                if (debug) console.warn("Failed loading scene:", scene);
+                return false;
+            }
             if (this._currentIndex === index) {
                 GameObject.add(scene.asset, this.gameObject);
                 // save the loaded scene as an url parameter
@@ -186,10 +204,10 @@ export class SceneSwitcher extends Behaviour {
     }
 
     private tryLoadFromQueryParam() {
-        if (!this.queryParameterName?.length) return false;
+        if (!this.queryParameterName?.length) return couldNotLoadScenePromise;
         // try restore the scene from the url
         const value = getParam(this.queryParameterName);
-        if (typeof value === "boolean") return false;
+        if (typeof value === "boolean") return couldNotLoadScenePromise;
         return this.trySelectSceneFromValue(value);
     }
 
@@ -217,7 +235,7 @@ export class SceneSwitcher extends Behaviour {
             }
         }
 
-        if (isLocalNetwork()) console.warn("Unknown scene value or index: \"" + value + "\"", this)
+        if (isLocalNetwork()) console.warn("Can not find scene: \"" + value + "\"", this)
 
         return couldNotLoadScenePromise;
     }

package/src/engine-components/timeline/PlayableDirector.ts

@@ -172,7 +172,7 @@ export class PlayableDirector extends Behaviour {
                 await Promise.all(promises);
                 if (!this._isPlaying) return;
             }
-            while(this._audioTracks.length > 0 && this._isPlaying && !AudioSource.userInteractionRegistered && this.waitForAudio) 
+            while (this._audioTracks.length > 0 && this._isPlaying && !AudioSource.userInteractionRegistered && this.waitForAudio)
                 await delay(200);
         }
         this._internalUpdateRoutine = this.startCoroutine(this.internalUpdate());
@@ -211,9 +211,9 @@ export class PlayableDirector extends Behaviour {
         let t = this._time;
         switch (this.extrapolationMode) {
             case DirectorWrapMode.Hold:
-                if(this._speed > 0)
+                if (this._speed > 0)
                     t = Math.min(t, this._duration);
-                else if(this._speed < 0)
+                else if (this._speed < 0)
                     t = Math.max(t, 0);
                 this._time = t;
                 break;
@@ -242,7 +242,7 @@ export class PlayableDirector extends Behaviour {
         }
     }
 
-    get audioTracks() : Tracks.AudioTrackHandler[] {
+    get audioTracks(): Tracks.AudioTrackHandler[] {
         return this._audioTracks;
     }
 
@@ -362,7 +362,7 @@ export class PlayableDirector extends Behaviour {
                         if (debug)
                             console.log("Resolved binding", binding, "to", obj);
                         track.outputs[i] = obj;
-                        if(obj instanceof Animator) {
+                        if (obj instanceof Animator) {
                             // TODO: should disable? animator but this is not the animator that is currently on the object? needs investigation
                             // console.log("DISABLE ANIMATOR", obj, obj.name, binding, this._guidsMap);
                             // obj.enabled = false;
@@ -376,7 +376,7 @@ export class PlayableDirector extends Behaviour {
                         continue;
                     }
                     // if the binding is missing remove it to avoid unnecessary loops
-                    if (track.type !== Models.TrackType.Audio && track.type !== Models.TrackType.Control && track.type !== Models.TrackType.Marker)
+                    if (track.type !== Models.TrackType.Audio && track.type !== Models.TrackType.Control && track.type !== Models.TrackType.Marker && track.type !== Models.TrackType.Signal)
                         console.warn("Missing binding", binding, track.name, track.type, this.name, this.playableAsset.name);
                 }
             }
@@ -416,8 +416,11 @@ export class PlayableDirector extends Behaviour {
             for (const clip of track.clips) {
                 if (clip.end > this._duration) this._duration = clip.end;
             }
+            for(const marker of track.markers){
+                if (marker.time > this._duration) this._duration = marker.time + .001;
+            }
         }
-        // console.log("timeline duration", this._duration);
+        // console.log("timeline duration", this._duration, this.playableAsset);
     }
 
     private setupAndCreateTrackHandlers() {
@@ -442,15 +445,15 @@ export class PlayableDirector extends Behaviour {
             // only handle animation tracks
             if (track.type === Models.TrackType.Animation) {
                 if (track.clips.length <= 0) {
-                    if(debug) console.warn("Animation track has no clips", track);
+                    if (debug) console.warn("Animation track has no clips", track);
                     continue;
                 }
                 // loop outputs / bindings, they should contain animator references
                 for (let i = track.outputs.length - 1; i >= 0; i--) {
                     let binding = track.outputs[i] as Animator;
-                    if(binding instanceof Object3D){
+                    if (binding instanceof Object3D) {
                         const anim = GameObject.getOrAddComponent(binding, Animator);
-                        if(anim) binding = anim;
+                        if (anim) binding = anim;
                     }
                     const animationClips = binding?.gameObject?.animations;
                     if (animationClips) {

package/src/engine-components/timeline/SignalAsset.ts

@@ -7,28 +7,55 @@ import { serializable } from "../../engine/engine_serialization_decorator";
 
 
 export class SignalAsset {
+    @serializable()
     guid!: string;
 }
 
-export class SignalReceiverEvent implements ISerializable {
+export class SignalReceiverEvent {
+    @serializable(SignalAsset)
     signal!: SignalAsset;
+    @serializable(EventList)
     reaction!: EventList;
-
-    $serializedTypes = {
-        signal: SignalAsset,
-        reaction: EventList
-    }
 }
 
 export class SignalReceiver extends Behaviour {
 
+    private static receivers: { [key: string]: SignalReceiver[] } = {};
+
+    static invoke(guid: string) {
+        if (SignalReceiver.receivers[guid]) {
+            const receivers = SignalReceiver.receivers[guid];
+            if (!receivers) return;
+            for (const rec of receivers)
+                rec.invoke(guid);
+        }
+    }
+
+
 
     @serializable(SignalReceiverEvent)
     events?: SignalReceiverEvent[];
 
+    onEnable(): void {
+        if (this.events) {
+            for (const evt of this.events) {
+                if (!SignalReceiver.receivers[evt.signal.guid])
+                    SignalReceiver.receivers[evt.signal.guid] = [];
+                SignalReceiver.receivers[evt.signal.guid].push(this);
+            }
+        }
+    }
 
-    start() {
-        console.log(this);
+    onDisable(): void {
+        if (this.events) {
+            for (const evt of this.events) {
+                if (SignalReceiver.receivers[evt.signal.guid]) {
+                    const idx = SignalReceiver.receivers[evt.signal.guid].indexOf(this);
+                    if (idx >= 0)
+                        SignalReceiver.receivers[evt.signal.guid].splice(idx, 1);
+                }
+            }
+        }
     }
 
     invoke(sig: SignalAsset | string) {

package/src/engine-components/timeline/TimelineTracks.ts

@@ -225,8 +225,7 @@ export class AnimationTrackHandler extends TrackHandler {
             // We need to disable the animator component in case it also animates
             // which overrides the timeline
             this._animator = GameObject.getComponent(this.target, Animator) ?? null;
-            if (this._animator)
-            {
+            if (this._animator) {
                 this._animatorWasEnabled = this._animator.enabled;
                 this._animator.enabled = false;
             }
@@ -331,7 +330,7 @@ export class AnimationTrackHandler extends TrackHandler {
                 weight *= this.director.weight;
 
                 let handleLoop = isInTimeRange;
-                if(doPreExtrapolate){
+                if (doPreExtrapolate) {
                     if (preExtrapolation !== Models.ClipExtrapolation.Hold) {
                         time += model.start;
                         handleLoop = true;
@@ -666,7 +665,7 @@ export class AudioTrackHandler extends TrackHandler {
     public static dispose() {
         AudioTrackHandler._currentlyLoading.clear();
     }
-    
+
     private handleAudioLoading(model: Models.ClipModel, audio: THREE.Audio): Promise<AudioBuffer | null> | null {
         if (!this._audioLoader) {
             this._audioLoader = new THREE.AudioLoader();
@@ -681,7 +680,7 @@ export class AudioTrackHandler extends TrackHandler {
             });
             return promise;
         }
-        
+
         if (debug) console.warn("LOAD audio track", path, this.director.sourceId);
         const loadingPromise = new Promise<AudioBuffer | null>((resolve, _reject) => {
             this._audioLoader!.load(path,
@@ -705,23 +704,48 @@ export class SignalTrackHandler extends TrackHandler {
     didTrigger: boolean[] = [];
     receivers: Array<SignalReceiver | null> = [];
 
+    // private _lastTime: number = -1;
+
     evaluate(time: number) {
-        if (this.receivers.length <= 0) return;
         if (this.track.muted) return;
+
+        // let lastTime = this._lastTime;
+        // if (lastTime === -1) lastTime = time;
+        // this._lastTime = time;
+
         for (let i = 0; i < this.models.length; i++) {
             const model = this.models[i];
             const wasTriggered = this.didTrigger[i];
             const td = model.time - time;
-            let isActive = model.retroActive ? td < 0 : (td < 0 && Math.abs(td) < .1);
+            let isActive = false;
+            if (model.retroActive) {
+                isActive = td <= 0.000001;
+            }
+            // TODO: handle signal asset at time 0 (only trigger when time is 0)
+            // else if (model.time < .001) {
+            //     if (td <= 0.000001 && lastTime > time)
+            //         isActive = true;
+            // }
+            else {
+                const abs = Math.abs(td);
+                if (abs >= .00001 && abs < .1) {
+                    isActive = true;
+                }
+            }
+            // console.log(time, td, isActive);
             if (isActive) {
                 if (!wasTriggered) {
                     this.didTrigger[i] = true;
-                    for (const rec of this.receivers) {
-                        if (!rec) continue;
-                        rec.invoke(model.asset);
+                    // If a signal doesnt have any explicit receivers it will invoke the signal globally
+                    if (this.receivers?.length <= 0) {
+                        SignalReceiver.invoke(model.asset);
+                    }
+                    else {
+                        for (const rec of this.receivers) {
+                            if (!rec) continue;
+                            rec.invoke(model.asset);
+                        }
                     }
-                    // console.log("TRIGGER " + model.asset);
-                    // TimelineSignals.invoke(model.asset);
                 }
             }
             else {