void OnEnable()
{
director.played += Initialize;
originalWrapMode = director.extrapolationMode;
// director.extrapolationMode = DirectorWrapMode.Hold;
}
public PlayableDirectorExtended(
PlayableDirector _PlayableDirector,
DirectorWrapMode _DirectorWrapMode,
bool _State)
{
m_PlayableDirector = _PlayableDirector;
m_DirectorWrapMode = _DirectorWrapMode;
m_State = _State;
}
public void Play(PlayableAsset asset, DirectorWrapMode mode)
{
if (asset == null)
{
throw new ArgumentNullException("asset");
}
this.playableAsset = asset;
this.extrapolationMode = mode;
this.Play();
}
public override void OnInspectorGUI()
{
if (this.PlayableAssetOutputsChanged())
{
this.SynchSceneBindings();
}
base.serializedObject.Update();
if (DirectorEditor.PropertyFieldAsObject(this.m_PlayableAsset, DirectorEditor.Styles.PlayableText, typeof(PlayableAsset), false, false))
{
base.serializedObject.ApplyModifiedProperties();
this.SynchSceneBindings();
InternalEditorUtility.RepaintAllViews();
}
EditorGUILayout.PropertyField(this.m_UpdateMethod, DirectorEditor.Styles.UpdateMethod, new GUILayoutOption[0]);
Rect controlRect = EditorGUILayout.GetControlRect(true, new GUILayoutOption[0]);
GUIContent label = EditorGUI.BeginProperty(controlRect, DirectorEditor.Styles.InitialStateContent, this.m_InitialState);
bool flag = this.m_InitialState.enumValueIndex != 0;
EditorGUI.BeginChangeCheck();
flag = EditorGUI.Toggle(controlRect, label, flag);
if (EditorGUI.EndChangeCheck())
{
this.m_InitialState.enumValueIndex = ((!flag) ? 0 : 1);
}
EditorGUI.EndProperty();
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_WrapMode, DirectorEditor.Styles.WrapModeContent, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
DirectorWrapMode enumValueIndex = (DirectorWrapMode)this.m_WrapMode.enumValueIndex;
foreach (PlayableDirector current in base.targets.OfType <PlayableDirector>())
{
current.extrapolationMode = enumValueIndex;
}
}
DirectorEditor.PropertyFieldAsFloat(this.m_InitialTime, DirectorEditor.Styles.InitialTimeContent);
if (Application.isPlaying)
{
this.CurrentTimeField();
}
if (base.targets.Length == 1)
{
PlayableAsset x = this.m_PlayableAsset.objectReferenceValue as PlayableAsset;
if (x != null)
{
this.DoDirectorBindingInspector();
}
}
base.serializedObject.ApplyModifiedProperties();
}
protected bool _PlayEffect(GuiEffect a_guiEffect, DirectorWrapMode a_eWrapMode, DirectorUpdateMode a_eUpdateMode, UnityAction <string> a_onFinished)
{
if (a_guiEffect == null || a_guiEffect.timelineAsset == null || m_objOwner.activeInHierarchy == false)
{
return(false);
}
m_director.Stop();
m_director.extrapolationMode = a_eWrapMode;
m_director.initialTime = 0;
m_director.timeUpdateMode = a_eUpdateMode;
m_director.Play(a_guiEffect.timelineAsset);
m_currEfect = a_guiEffect;
m_currEfect.onFinished.AddListener(a_onFinished);
return(true);
}
public void PlayEffect(string a_strEffectName, DirectorWrapMode a_eWrapMode, DirectorUpdateMode a_eUpdateMode, UnityAction <string> a_onFinished = null)
{
GuiEffect guiEffect = null;
for (int i = 0; i < commonEffects.Count; ++i)
{
if (commonEffects[i].strName == a_strEffectName)
{
guiEffect = commonEffects[i];
break;
}
}
if (guiEffect == null)
{
return;
}
_PlayEffect(guiEffect, a_eWrapMode, a_eUpdateMode, a_onFinished);
}
private void UpdateTime(Playable playable)
{
double num = Math.Max(0.1, this.director.get_playableAsset().get_duration());
DirectorWrapMode extrapolationMode = this.director.get_extrapolationMode();
if (extrapolationMode != null)
{
if (extrapolationMode != 1)
{
if (extrapolationMode == 2)
{
this.director.set_time(PlayableExtensions.GetTime <Playable>(playable));
}
}
else
{
this.director.set_time(Math.Max(0.0, PlayableExtensions.GetTime <Playable>(playable) % num));
}
}
else
{
this.director.set_time(Math.Min(num, Math.Max(0.0, PlayableExtensions.GetTime <Playable>(playable))));
}
}
private void UpdateTime(Playable playable)
{
double num = Math.Max(0.1, this.director.playableAsset.duration);
DirectorWrapMode extrapolationMode = this.director.extrapolationMode;
if (extrapolationMode != DirectorWrapMode.Hold)
{
if (extrapolationMode != DirectorWrapMode.Loop)
{
if (extrapolationMode == DirectorWrapMode.None)
{
this.director.time = playable.GetTime <Playable>();
}
}
else
{
this.director.time = Math.Max(0.0, playable.GetTime <Playable>() % num);
}
}
else
{
this.director.time = Math.Min(num, Math.Max(0.0, playable.GetTime <Playable>()));
}
}
/// <summary>
/// Creates and initializes a ScriptPlayable with a TimeNotificationBehaviour.
/// </summary>
/// <param name="graph">The playable graph.</param>
/// <param name="duration">The duration of the playable.</param>
/// <param name="loopMode">The loop mode of the playable.</param>
/// <returns>A new TimeNotificationBehaviour linked to the PlayableGraph.</returns>
public static ScriptPlayable <TimeNotificationBehaviour> Create(PlayableGraph graph, double duration, DirectorWrapMode loopMode)
{
var notificationsPlayable = ScriptPlayable <TimeNotificationBehaviour> .Create(graph);
notificationsPlayable.SetDuration(duration);
notificationsPlayable.SetTimeWrapMode(loopMode);
notificationsPlayable.SetPropagateSetTime(true);
return(notificationsPlayable);
}
internal static void SetTimeWrapMode <U>(this U playable, DirectorWrapMode value) where U : struct, IPlayable
{
playable.GetHandle().SetTimeWrapMode(value);
}
//Play clip in playable director PlayPlayableDirector(timelineAssets[id], DirectorWrapMode. )
public void PlayPlayableDirector(TimelineAsset timelineAsset, DirectorWrapMode directorWrap)
{
playableDirector.extrapolationMode = directorWrap; //Set director wrap mode in playableDirector
playableDirector.playableAsset = timelineAsset; // Set clip
playableDirector.Play(); //Play
}
extern internal void SetTimeWrapMode(DirectorWrapMode mode);
private static extern void SetTimeWrapMode_Injected(ref PlayableHandle _unity_self, DirectorWrapMode mode);
public static ScriptPlayable <TimeNotificationBehaviour> CreateNotificationsPlayable(PlayableGraph graph, IEnumerable <IMarker> markers, double duration, DirectorWrapMode extrapolationMode)
{
var notificationPlayable = ScriptPlayable <TimeNotificationBehaviour> .Null;
foreach (var e in markers)
{
var notif = e as INotification;
if (notif == null)
{
continue;
}
if (notificationPlayable.Equals(ScriptPlayable <TimeNotificationBehaviour> .Null))
{
notificationPlayable = TimeNotificationBehaviour.Create(graph,
duration, extrapolationMode);
}
var time = (DiscreteTime)e.time;
var tlDuration = (DiscreteTime)duration;
if (time >= tlDuration && time <= tlDuration.OneTickAfter() && tlDuration != 0)
{
time = tlDuration.OneTickBefore();
}
var notificationOptionProvider = e as INotificationOptionProvider;
if (notificationOptionProvider != null)
{
notificationPlayable.GetBehaviour().AddNotification((double)time, notif, notificationOptionProvider.flags);
}
else
{
notificationPlayable.GetBehaviour().AddNotification((double)time, notif);
}
}
return(notificationPlayable);
}
internal void SetTimeWrapMode(DirectorWrapMode mode)
{
PlayableHandle.SetTimeWrapMode_Injected(ref this, mode);
}
private extern void SetWrapMode(DirectorWrapMode mode);
public void Play(PlayableAsset playableAsset, DirectorWrapMode directorWrapMode)
{
m_Director.Play(playableAsset, directorWrapMode);
}
