Bug Timeline Markers Do Not Fire Reliably in Low FPS Situations

I've run into a problem that I'd like to see if I can get visibility on that appears to be a timeline bug. We have customized markers in our game that signal a timeline to pause so that we can display narrative bubbles that the user has unlimited time to read and dismiss before the timeline continues.

We ran into a problem though where even though we followed the recommendation here: https://forum.unity.com/threads/playdirector-pause-not-immediate.827373/#post-5801512 Where we scan the marker's time field and set the duration of the playable to a hard value.

Unity 2020.1.14f1
TimelinePackage 1.4.4

I submitted bug# 1294256 but I'm wondering if anyone has experienced this? It appears that this primarily appears in low frame rate situations, but we need timelines to be deterministic even in low frame rate situations. It basically destroys our cutscene system because we cannot deterministically know how many stop points there are going to be in a conversation.

@seant_unity if you have any insight I'd be happy to discuss aspects of the bug report here.

 

You are correct that it works correctly if all of the markers are on the master timeline.

However, that is not the workflow that our animators wanted. We split our cutscenes into separate directors for the different "chunks" so that they can retime sequences that sometimes have dozens of tracks and a reduction of conflicts as they can work on the same cutscene at the same time (as long as they work on different chunks). So they want to keep the markers on the lowest-level timeline as that is closest to the individual curves/tracks. They also still want the ability to scrub the entire timeline so that is the purpose of the parent timeline.

Is this child control track marker skipping something that you can fix?

 

As a user, I expect that the timeline markers to be able to be deterministic regardless if the marker is located in a control track or at the master track level regardless of framerate. If I'm understanding correctly, you're saying that this is a bug that you will not fix and that I should take ownership of firing all the notifications by parsing the notifications manually by doing a query of all of the markers from the master/control tracks.

If true, I'm disappointed that this is your recommended fix. I feel bad for the users who will miss this thread and will depend on this behavior and end up shipping buggy software as a result. I'd recommend investing the time to have the timeline manage their markers deterministically or at least notify the users that markers at the control level will not fire reliably. Leaving this unintended behavior of the timeline sometimes firing markers is not why I spent hours of my day to track down the issue and to submit a bug report.

 

Well, I guess we're both saying it's a condition of the code failing, but you're saying it's working as intended and I'm saying it's a bug. Maybe there's a terminology difference, but a subtimeline is an embedded timeline via a control track right? So in my bug, a subtimeline's markers are not deterministically firing. It is skipping the firing of the markers when the parent director pulls the subdirector forward unless there's a frame before the marker on that sub-timeline. Is there some way of setting up an embedded timeline without a director target via control track that you're saying would work that is exposed via the GUI that animators can use?

Since you seem reluctant to acknowledge this as an issue you want to fix. I went through and queried the markers and am firing them myself from the master director and that seems to work. However, I'm disappointed that this is yet another hoop that you expect your users to jump through to get around timeline code that isn't handling low framerate cases correctly. This issue on top of the behavior of letting a timeline director go past markers that should pause the timeline are two areas I wish I didn't have to manually handle in our code. Both of these scenarios IMO are bugs and can cause a lot of unintended bugs in user code that rely on the markers firing in a specific way.

 

8 months later I can confirm this is still an issue. We are working with nested timelines much the way you would with prefabs. The master timeline runs the whole game and the sub timelines process smaller sections of the game. We have signal receivers on the sub timelines that are not firing, particularly if they are on or close to frame 0 in the sub timeline.

Now all of our timelines are updating on GameTime and none of them are set to play on awake. The strange thing is this isn't random or occasional, its happening every time we play through the game. The signals on the first few frames of the timelines are not firing.

 

I want to share my solution to this problem:

1. Attach the provided TimelinePausesManager to the PlayableDirector
2. Change your signals to be PauseSignals in your timeline

The timeline will pause automatically and accurately to those signals.

Code (CSharp):

1. using System.Collections.Generic;
2. using System.Linq;
3. using UnityEngine;
4. using UnityEngine.Events;
5. using UnityEngine.Playables;
6. using UnityEngine.Timeline;
7.  
8. namespace Utils
9. {
10.     // Special signal used to pause the timeline precisely
11.     public class PauseSignalEmitter : SignalEmitter { }
12.  
13.     // Attach this component to the PlayableDirector in order to correctly setup the pauses
14.     [RequireComponent(typeof(PlayableDirector))]
15.     public class TimelinePausesManager : MonoBehaviour
16.     {
17.         private PlayableDirector _director;
18.         private List<PauseSignalEmitter> _markers;
19.  
20.         private void Awake()
21.         {
22.             _director = GetComponent<PlayableDirector>();
23.             _markers = GetAllMarkers<PauseSignalEmitter>(_director);
24.  
25.             if (_markers.Count > 0)
26.                 SetupPauses();
27.         }
28.  
29.         private void SetupPauses()
30.         {
31.             // Update timeline duration now and on any play/pause events
32.             UpdateTimelineDuration();
33.             _director.played += _ => UpdateTimelineDuration();
34.             _director.paused += _ => UpdateTimelineDuration();
35.  
36.             // Make sure that the signal receiver exists
37.             var signalReceiver = GetComponent<SignalReceiver>();
38.             if (signalReceiver == null)
39.                 signalReceiver = gameObject.AddComponent<SignalReceiver>();
40.  
41.             // Pause the timeline automatically on each pause marker
42.             foreach (var marker in _markers)
43.             {
44.                 var reaction = signalReceiver.GetReaction(marker.asset);
45.                 if (reaction == null)
46.                 {
47.                     reaction = new UnityEvent();
48.                     signalReceiver.AddReaction(marker.asset, reaction);
49.                 }
50.                 reaction.AddListener(_director.Pause);
51.             }
52.         }
53.  
54.         private void UpdateTimelineDuration()
55.         {
56.             // Find the next pause marker that will be hit
57.             var nextMarker = _markers
58.                 .Where(m => m.time > _director.time)
59.                 .FirstOrDefault();
60.  
61.             // Force the timeline duration to end exactly on that marker
62.             // (or to the original duration if there are no pause markers ahead)
63.             var nextMarkerTime = nextMarker != null ? nextMarker.time : _director.duration;
64.             _director.playableGraph.GetRootPlayable(0).SetDuration(nextMarkerTime);
65.         }
66.  
67.         /// Find all markers of a specified type
68.         private static List<T> GetAllMarkers<T>(PlayableDirector director) where T : IMarker
69.         {
70.             List<T> markers = new();
71.  
72.             var timeline = director.playableAsset as TimelineAsset;
73.             if (timeline == null)
74.                 return markers;
75.  
76.             if (timeline.markerTrack == null)
77.                 return markers;
78.  
79.             foreach (var marker in timeline.markerTrack.GetMarkers())
80.                 if (marker is T tMarker)
81.                     markers.Add(tMarker);
82.  
83.             return markers;
84.         }
85.     }
86. }

 

Has anyone tried this solution from @Oneiros90
I'm not using nested timelines but the playhead is sometimes stopping up to 8 frames after the pause signal. I'm hoping this will work but I don't get step 2 - Change your signals to PauseSignals. Like name them PauseSignals? I don't see where the code looks for anything named PauseSignal... and I have many other signals. If anyone has some clarification on implementing this, it'd be appreciated.