@needle-tools/engine 3.1.0-alpha.2 → 3.2.1-alpha

package/src/engine-components/RendererLightmap.ts

@@ -14,7 +14,7 @@ export class RendererLightmap {
     set lightmap(tex: Texture | null) {
         if (tex !== this.lightmapTexture) {
             this.lightmapTexture = tex;
-            this.setupLightmap();
+            this.applyLightmap();
         }
     }
 
@@ -27,8 +27,6 @@ export class RendererLightmap {
     private lightmapScaleOffsetUniform = { value: new THREE.Vector4(1, 1, 0, 0) };
     private lightmapUniform: { value: THREE.Texture | null } = { value: null };
 
-    private beforeRenderCallback?: OnBeforeRenderCallback;
-
     constructor(gameObject: GameObject, context: Context) {
         this.gameObject = gameObject;
         this.context = context;
@@ -44,20 +42,19 @@ export class RendererLightmap {
 
         const debugLightmaps = debug;
         if (debugLightmaps) this.setLightmapDebugMaterial();
-        this.setupLightmap();
+        this.applyLightmap();
     }
 
     bindOnBeforeRender() {
-        this.beforeRenderCallback = this.onBeforeRenderThreeComplete.bind(this);
-        this.context.addBeforeRenderListener(this.gameObject, this.beforeRenderCallback);
-        // this.gameObject.onBeforeRender = this.onBeforeRenderThreeComplete.bind(this);
+        this.context.removeBeforeRenderListener(this.gameObject, this.onBeforeRenderThreeComplete);
+        this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThreeComplete);
     }
 
-    private onBeforeRenderThreeComplete(_renderer, _scene, _camera, _geometry, material, _group) {
+    private onBeforeRenderThreeComplete = (_renderer, _scene, _camera, _geometry, material, _group) => {
         this.onBeforeRenderThree(material);
     }
 
-    private setupLightmap() {
+    private applyLightmap() {
 
         if (this.gameObject.type === "Object3D") {
             // console.warn("Can not add lightmap. Is this object missing a renderer?");
@@ -65,13 +62,12 @@ export class RendererLightmap {
         }
 
         if (this.gameObject.type === "Group") {
-            console.warn("Lightmap on multimaterial object is not supported yet... please ask kindly for implementation.");
+            console.warn("Lightmap on multimaterial object is not supported yet... please open a feature request on https://github.com/needle-tools/needle-engine-support if your project requires it");
             return;
         }
 
         console.assert(this.gameObject.type === "Mesh", "Lightmap only works on meshes", this);
 
-
         const mesh = this.gameObject as unknown as THREE.Mesh;
         // TODO: ensure uv2 exists
         if (!mesh.geometry.getAttribute("uv2"))

package/src/engine-components/SceneSwitcher.ts

@@ -0,0 +1,240 @@
+import { AssetReference } from "../engine/engine_addressables";
+import { NeedleEngineHTMLElement } from "../engine/engine_element";
+import { InputEvents } from "../engine/engine_input";
+import { isLocalNetwork } from "../engine/engine_networking_utils";
+import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry";
+import { getParam, isMobileDevice, setParamWithoutReload } from "../engine/engine_utils";
+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, _ => {
+    if (!NeedleEngineHTMLElement.observedAttributes.includes(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME))
+        NeedleEngineHTMLElement.observedAttributes.push(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME);
+});
+
+const couldNotLoadScenePromise = Promise.resolve(false);
+
+export class SceneSwitcher extends Behaviour {
+
+    @serializable(AssetReference)
+    scenes!: AssetReference[];
+
+    /** the url parameter that is set/used to store the currently loaded scene in, set to "" to disable */
+    @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;
+
+    /** when enabled you can switch between scenes using keyboard left, right, A and D or number keys */
+    @serializable()
+    useKeyboard: boolean = true;
+
+    /** when enabled you can switch between scenes using swipe (mobile only) */
+    @serializable()
+    useSwipe: boolean = true;
+
+
+    private _currentIndex: number = -1;
+    private _currentScene: AssetReference | undefined = undefined;
+    private _engineElementOverserver: MutationObserver | undefined = undefined;
+
+    start() {
+        if (!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);
+            }
+            finally {
+                // this.lock = locked;
+            }
+        }
+    }
+
+    onEnable(): void {
+        globalThis.addEventListener("popstate", this.onPopState);
+        this.context.input.addEventListener(InputEvents.KeyDown, this.onKeyDown);
+        this.context.input.addEventListener(InputEvents.PointerMove, this.onPointerMove);
+        this.context.input.addEventListener(InputEvents.PointerUp, this.onPointerUp);
+
+        if (!this._engineElementOverserver) {
+            this._engineElementOverserver = new MutationObserver((mutations) => {
+                for (const mut of mutations) {
+                    if (mut.type === "attributes" && mut.attributeName === ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME) {
+                        const value = this.context.domElement.getAttribute(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME);
+                        if (value !== null) {
+                            this.trySelectSceneFromValue(value);
+                        }
+                    }
+                }
+            });
+        }
+
+        this._engineElementOverserver.observe(this.context.domElement, {
+            attributes: true
+        });
+    }
+
+    onDisable(): void {
+        globalThis.removeEventListener("popstate", this.onPopState);
+        this.context.input.removeEventListener(InputEvents.KeyDown, this.onKeyDown);
+        this.context.input.removeEventListener(InputEvents.PointerMove, this.onPointerMove);
+        this.context.input.removeEventListener(InputEvents.PointerUp, this.onPointerUp);
+    }
+
+    private onPopState = async (_state: PopStateEvent) => {
+        if (!this.useHistory) return;
+        let wasUsingHistory = this.useHistory;
+        try {
+            this.useHistory = false;
+            await this.tryLoadFromQueryParam();
+        }
+        finally {
+            this.useHistory = wasUsingHistory;
+        }
+    }
+
+    private normalizedSwipeThresholdX = 0.1;
+    private _didSwipe: boolean = false;
+    private onPointerMove = (e: any) => {
+        if (!this._didSwipe && e.button === 0 && e.pointerType === "touch" && this.context.input.getPointerPressedCount() === 1) {
+            const delta = this.context.input.getPointerPositionDelta(e.button);
+            if (delta) {
+                const normalizedX = delta.x / this.context.domWidth;
+                if (normalizedX >= this.normalizedSwipeThresholdX) {
+                    this._didSwipe = true;
+                    this.selectPrev();
+                }
+                else if (normalizedX <= -this.normalizedSwipeThresholdX) {
+                    this._didSwipe = true;
+                    this.selectNext();
+                }
+            }
+        }
+    }
+
+    private onPointerUp = (e: any) => {
+        if (e.button === 0) {
+            this._didSwipe = false;
+        }
+    };
+
+    private onKeyDown = (e: any) => {
+        if (!this.useKeyboard) return;
+        if (!this.scenes) return;
+        const key = e.key.toLowerCase();
+        if (!key) return;
+        const index = parseInt(key) - 1;
+        if (index >= 0) {
+            this.trySelectSceneFromValue(index);
+            return;
+        }
+        switch (key) {
+            case "arrowright":
+            case "d":
+                this.selectNext();
+                break;
+            case "arrowleft":
+            case "a":
+                this.selectPrev();
+                break;
+        }
+    }
+
+    selectNext(): Promise<boolean> {
+        return this.select(this._currentIndex + 1);
+    }
+
+    selectPrev(): Promise<boolean> {
+        return this.select(this._currentIndex - 1);
+    }
+
+    select(index: number): Promise<boolean> {
+        if (debug) console.log("select", index)
+        if (!this.scenes?.length) return couldNotLoadScenePromise;
+        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);
+    }
+
+    async switchScene(scene: AssetReference): Promise<boolean> {
+        if (scene === this._currentScene) return true;
+        if (this._currentScene)
+            this._currentScene.unload();
+        const index = this._currentIndex = this.scenes?.indexOf(scene) ?? -1;
+        this._currentScene = scene;
+        try {
+            await scene.loadAssetAsync();
+            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
+                if (this.queryParameterName?.length)
+                    setParamWithoutReload(this.queryParameterName, index.toString(), this.useHistory);
+                return true;
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        return false;
+    }
+
+    private tryLoadFromQueryParam() {
+        if (!this.queryParameterName?.length) return false;
+        // try restore the scene from the url
+        const value = getParam(this.queryParameterName);
+        if (typeof value === "boolean") return false;
+        return this.trySelectSceneFromValue(value);
+    }
+
+    /** try to select a scene from a string or index */
+    private trySelectSceneFromValue(value: string | number) {
+
+        if (typeof value === "string") {
+            const index = parseInt(value as string);
+            if (index >= 0 && index < this.scenes.length) {
+                return this.select(index);;
+            }
+            else {
+                // Try to find a scene with a matching name
+                for (let i = 0; i < this.scenes.length; i++) {
+                    const scene = this.scenes[i];
+                    if (scene.uri.toLowerCase().includes(value)) {
+                        return this.select(i);;
+                    }
+                }
+            }
+        }
+        else if (typeof value === "number") {
+            if (value >= 0 && value < this.scenes.length) {
+                return this.select(value);;
+            }
+        }
+
+        if (isLocalNetwork()) console.warn("Unknown scene value or index: \"" + value + "\"", this)
+
+        return couldNotLoadScenePromise;
+    }
+}

package/src/engine-components/ScreenCapture.ts

@@ -96,6 +96,7 @@ export class ScreenCapture extends Behaviour implements IPointerClickHandler {
             console.log("Screensharing", this.name, this);
         AudioSource.registerWaitForAllowAudio(() => {
             if (this.videoPlayer && this._currentStream && this._currentMode === ScreenCaptureMode.Receiving) {
+                this.videoPlayer.playInBackground = true;
                 this.videoPlayer.setVideo(this._currentStream);
             }
         });

package/src/engine-components/VideoPlayer.ts

@@ -52,7 +52,7 @@ export class VideoPlayer extends Behaviour {
 
     @serializable()
     aspectMode: AspectMode = AspectMode.None;
-    
+
     @serializable(URL)
     private clip?: string | MediaStream | null = null;
 
@@ -106,12 +106,12 @@ export class VideoPlayer extends Behaviour {
     get isPlaying(): boolean {
         const video = this._videoElement;
         if (video) {
-            if(video.currentTime > 0 && !video.paused && !video.ended
+            if (video.currentTime > 0 && !video.paused && !video.ended
                 && video.readyState > video.HAVE_CURRENT_DATA)
                 return true;
-            else if(video.srcObject){
+            else if (video.srcObject) {
                 const stream = video.srcObject as MediaStream;
-                if(stream.active) return true;
+                if (stream.active) return true;
             }
         }
         return false;
@@ -149,6 +149,9 @@ export class VideoPlayer extends Behaviour {
     }
     private _muted: boolean = false;
 
+    /** Set this to false to pause video playback while the tab is not active */
+    playInBackground: boolean = true;
+
     private _crossOrigin: string | null = "anonymous";
 
     private audioOutputMode: VideoAudioOutputMode = VideoAudioOutputMode.AudioSource;
@@ -198,11 +201,13 @@ export class VideoPlayer extends Behaviour {
         window.addEventListener('visibilitychange', _evt => {
             switch (document.visibilityState) {
                 case "hidden":
-                    this.wasPlaying = this._isPlaying;
-                    this.pause();
+                    if(!this.playInBackground){
+                        this.wasPlaying = this._isPlaying;
+                        this.pause();
+                    }
                     break;
                 case "visible":
-                    if (this.wasPlaying) this.play();
+                    if (this.wasPlaying && !this._isPlaying) this.play();
                     break;
             }
         });
@@ -260,7 +265,7 @@ export class VideoPlayer extends Behaviour {
         this.updateVideoElementSettings();
         this._videoElement?.play().catch(err => {
             // https://developer.chrome.com/blog/play-request-was-interrupted/
-            if(debug)
+            if (debug)
                 console.error("Error playing video", err, "CODE=" + err.code, this.videoElement?.src, this);
             setTimeout(() => {
                 if (this._isPlaying && !this.destroyed && this.activeAndEnabled)
@@ -318,7 +323,7 @@ export class VideoPlayer extends Behaviour {
         this._videoTexture.flipY = false;
         this._videoTexture.encoding = THREE.sRGBEncoding;
         this.handleBeginPlaying(playAutomatically);
-        if(debug)
+        if (debug)
             console.log(this);
     }
 
@@ -420,7 +425,7 @@ export class VideoPlayer extends Behaviour {
         // dont open in fullscreen on ios
         this._videoElement.playsInline = true;
         let muted = !this._receivedInput && this.audioOutputMode !== VideoAudioOutputMode.None;
-        if(!muted && this._muted) muted = true;
+        if (!muted && this._muted) muted = true;
         this._videoElement.muted = muted;
         if (this.playOnAwake)
             this._videoElement.autoplay = true;
@@ -540,7 +545,7 @@ class VideoOverlay {
             if (!this._screenspaceModeQuad) return;
             this._screenspaceModeQuad.geometry.scale(2, 2, 2);
         }
-        
+
         const quad = this._screenspaceModeQuad;
         this.context.scene.add(quad);
         this.updateScreenspaceMaterialUniforms();

package/src/engine-components/XRFlag.ts

@@ -79,6 +79,9 @@ export class XRFlag extends Behaviour {
             XRFlag.firstApply = true;
             XRFlag.Apply();
         }
+        else {
+            this.UpdateVisible(XRState.Global);
+        }
     }
 
     onDestroy(): void {

package/src/engine-components/codegen/components.ts

@@ -114,6 +114,7 @@ export { RGBAColor } from "../js-extensions/RGBAColor";
 export { Rigidbody } from "../RigidBody";
 export { RotationBySpeedModule } from "../ParticleSystemModules";
 export { RotationOverLifetimeModule } from "../ParticleSystemModules";
+export { SceneSwitcher } from "../SceneSwitcher";
 export { ScreenCapture } from "../ScreenCapture";
 export { ScreenSpaceAmbientOcclusion } from "../postprocessing/Effects/ScreenspaceAmbientOcclusion";
 export { ShadowCatcher } from "../ShadowCatcher";

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,17 +445,16 @@ 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;
                     }
-                    if (typeof binding.enabled === "boolean") binding.enabled = false;
                     const animationClips = binding?.gameObject?.animations;
                     if (animationClips) {
                         const handler = new Tracks.AnimationTrackHandler();

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

@@ -145,7 +145,7 @@ export class AnimationTrackHandler extends TrackHandler {
     onPauseChanged() {
         // When the timeline is paused the original animator will be enabled again if it was before
         if (this._animator && this._animatorWasEnabled !== undefined) {
-            this._animator.enabled = this.director.isPaused ? this._animatorWasEnabled : false;
+            this._animator.enabled = this.director.isPlaying === false ? this._animatorWasEnabled : false;
         }
     }
 
@@ -225,7 +225,11 @@ 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;
-            this._animatorWasEnabled = this._animator?.enabled;
+            if (this._animator) {
+                this._animatorWasEnabled = this._animator.enabled;
+                this._animator.enabled = false;
+            }
+            else this._animatorWasEnabled = false;
         }
 
         // Clip Offsets
@@ -323,9 +327,10 @@ export class AnimationTrackHandler extends TrackHandler {
                 // const clip = this.clips[i];
                 let weight = 1;
                 weight *= this.evaluateWeight(time, i, this.models, isActive);
+                weight *= this.director.weight;
 
                 let handleLoop = isInTimeRange;
-                if(doPreExtrapolate){
+                if (doPreExtrapolate) {
                     if (preExtrapolation !== Models.ClipExtrapolation.Hold) {
                         time += model.start;
                         handleLoop = true;
@@ -370,7 +375,7 @@ export class AnimationTrackHandler extends TrackHandler {
                 else action.time = t;
 
                 action.timeScale = 0;
-                const effectiveWeight = weight * this.director.weight;
+                const effectiveWeight = weight;
                 action.weight = effectiveWeight;
                 action.clampWhenFinished = true;
                 if (!action.isRunning())
@@ -660,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();
@@ -675,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,
@@ -699,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 {