Feedback playDirector.Pause(); -- not immediate

Is anyone having problems where playDirector.Pause(); doesn't pause on the marker? It always pauses after 2-3 frames.

This happens on both scaled and unscaled time.

Thanks for the help!

 

Thanks so much for the answer. Can you please suggest a way to catch the marker more accurately?

Is there a way through C#?

I'm using Timeline to animate 10 UI Rect Transforms scaling from 0 to an end value. Is that too frame rate intensive?

Thanks

 

hi @seant_unity

Sorry for the late reply. Finally got time to try out your suggestion. It works very well and I'm able to catch each "marker" via C#. The actual Timeline markers are now empty placeholders (that don't use signal receivers), but are still very useful to accurately see each second to the 3rd decimal. (ie: firstMarkerTime, secondMarkerTime etc)

Thanks so much for the help!

 

This is a common use case for signals/markers and this is extremely problematic. If you have a pause marker on a timeline and it doesn't pause ON the marker, you end up with potentially other markers being executed as well that were supposed to execute after the pause.

For example, let's say you have a timeline that controls a cutscene that is interrupted with dialog. You setup a marker for each point in the cutscene where characters will be talking. If the markers are too close together, if there is a frame rate hitch you will completely jump/skip over talk markers. This makes Timeline extremely dangerous and rife with bugs depending on a lot of situations out of the dev's control (frame rate on device, memory allocation/cleanup, etc.).

This seems like a pretty common use case is there any way I can pause the timeline in a deterministic matter? I considered adding a flag to the marker receiver that would block all markers after the pause, but there's still the tricky situation of forcing the timeline BACK to when the pause occurred without processing the events prior.

Does anyone have any recommendations for this (@seant_unity)?

My ideal API would be something like:
m_director.PauseAtTime(pauseMarker.time);
This would block all previous markers from firing as well as any markers have yet to be processed after the current marker from firing (same frame markers would still fire once).

 

After trying to work around the problem using bool flags and resetting the director time back I gave up and did what you recommended by setting the director's duration and setting the behavior to hold. I'm glad that there is something that we can do to have this behavior. However, I'd really appreciate a mechanic that allows timeline to do this behavior without the scripting support in the future (maybe some type of marker interface?). Thanks!

 

Exactly.. I'm not sure why internally you can't just sample t, then if there's a marker nearby, CHANGE t to the marked time and do processing after.

 

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. }