public void RemoveClip(AnimationClipData clipData) { if (!this.trackClipList.Contains(clipData)) { throw new Exception("Track doesn't contains Clip"); } this.trackClipList.Remove(clipData); }
public void AddClip(AnimationClipData clipData) { if (this.trackClipList.Contains(clipData)) { throw new Exception("Track already contains Clip"); } this.trackClipList.Add(clipData); }
public void Process(float sequenceTime, float playbackRate) { this.allClips.Clear(); for (int i = 0; i < this.AnimationTimeline.AnimationTracks.Count; i++) { AnimationTrack animationTrack = this.AnimationTimeline.AnimationTracks[i]; for (int j = 0; j < animationTrack.TrackClips.Count; j++) { AnimationClipData animationClipData = animationTrack.TrackClips[j]; this.allClips.Add(animationClipData); animationClipData.RunningLayer = animationTrack.Layer; } } float num = sequenceTime - this.previousTime; float num2 = Mathf.Abs(num); bool flag = num < 0f; float num3 = USSequencer.SequenceUpdateRate; float num4 = this.previousTime + num3; if (flag) { this.AnimationTimeline.ResetAnimation(); this.previousTime = 0f; this.AnimationTimeline.Process(sequenceTime, playbackRate); } else { while (num2 > 0f) { this.cachedRunningClips.Clear(); for (int k = 0; k < this.allClips.Count; k++) { AnimationClipData animationClipData2 = this.allClips[k]; if (AnimationClipData.IsClipRunning(num4, animationClipData2)) { this.cachedRunningClips.Add(animationClipData2); } } this.cachedRunningClips.Sort((AnimationClipData x, AnimationClipData y) => x.StartTime.CompareTo(y.StartTime)); for (int l = 0; l < this.cachedRunningClips.Count; l++) { AnimationClipData animationClipData3 = this.cachedRunningClips[l]; this.PlayClip(animationClipData3, animationClipData3.RunningLayer, num4); } this.Animator.Update(num3); num2 -= USSequencer.SequenceUpdateRate; if (!Mathf.Approximately(num2, 1.401298E-45f) && num2 < USSequencer.SequenceUpdateRate) { num3 = num2; } num4 += num3; } } this.previousTime = sequenceTime; }
private void PlayClip(AnimationClipData clipToPlay, int layer, float sequenceTime) { float normalizedTime = (sequenceTime - clipToPlay.StartTime) / clipToPlay.StateDuration; if (clipToPlay.CrossFade) { float num = clipToPlay.TransitionDuration - (sequenceTime - clipToPlay.StartTime); num = Mathf.Clamp(num, 0f, float.PositiveInfinity); this.Animator.CrossFade(clipToPlay.StateName, num, layer, normalizedTime); } else { this.Animator.Play(clipToPlay.StateName, layer, normalizedTime); } }
private void SortClipsAtTime(float sequenceTime, IEnumerable <AnimationClipData> sortInto, AnimationClipData.StateCheck stateCheck) { for (int i = 0; i < this.allClips.Count; i++) { AnimationClipData animationClipData = this.allClips[i]; bool flag = sortInto.Contains(animationClipData); if (stateCheck(sequenceTime, animationClipData) && !flag) { if (!this.newProcessingClips.Contains(animationClipData)) { this.newProcessingClips.Add(animationClipData); } } else if (!stateCheck(sequenceTime, animationClipData) && flag && !this.newProcessingClips.Contains(animationClipData)) { this.newProcessingClips.Add(animationClipData); } } }
private void RemoveClip(AnimationClipData clip) { var undoName = "RemoveClip"; var animationTracks = AnimationTimeline.AnimationTracks; var cachedClipDataToRemove = cachedClipRenderData.Where(cachedClipData => cachedClipData.animationClipData == clip).ToList(); var tracksToRemoveClipFrom = animationTracks.Where(track => track.TrackClips.Contains(clip)); USUndoManager.RegisterCompleteObjectUndo(this, undoName); foreach (var cachedClipData in cachedClipDataToRemove) { cachedClipRenderData.Remove(cachedClipData); USUndoManager.DestroyImmediate(cachedClipData); } foreach (var trackToRemoveClipFrom in tracksToRemoveClipFrom) { USUndoManager.RegisterCompleteObjectUndo(trackToRemoveClipFrom, undoName); trackToRemoveClipFrom.RemoveClip(clip); USUndoManager.DestroyImmediate(clip); } }
private void PlayClip(AnimationClipData clipToPlay, int layer, float sequenceTime) { var normalizedTime = (sequenceTime - clipToPlay.StartTime) / clipToPlay.StateDuration; if (clipToPlay.CrossFade) { // The calculation and clamp are here, to resolve issues with big timesteps. // crossFadeTime will not always be equal to clipToPlay.transitionDuration, for insance // if the timeStep allows for a step of 0.5, we'll be 0.5s into the crossfade. var crossFadeTime = clipToPlay.TransitionDuration - (sequenceTime - clipToPlay.StartTime); crossFadeTime = Mathf.Clamp(crossFadeTime, 0.0f, Mathf.Infinity); Animator.CrossFade(clipToPlay.StateName, crossFadeTime, layer, normalizedTime); } else { Animator.Play(clipToPlay.StateName, layer, normalizedTime); } //var message = string.Format("state: {0}, nt: {1}, cf: {2}", clipToPlay.StateName, normalizedTime, clipToPlay.CrossFade); //Debug.LogError(message); }
private void SortNewProcessingClips(float sequenceTime) { var orderedNewProcessingClips = newProcessingClips.OrderBy(processingClip => processingClip.StartTime); foreach (var clipData in orderedNewProcessingClips) { if (AnimationClipData.IsClipNotRunning(sequenceTime, clipData)) { notRunningClips.Add(clipData); } else if (!AnimationClipData.IsClipNotRunning(sequenceTime, clipData) && notRunningClips.Contains(clipData)) { notRunningClips.Remove(clipData); } if (AnimationClipData.IsClipRunning(sequenceTime, clipData)) { runningClips.Add(clipData); PlayClip(clipData, clipData.RunningLayer, sequenceTime); } else if (!AnimationClipData.IsClipRunning(sequenceTime, clipData) && runningClips.Contains(clipData)) { runningClips.Remove(clipData); } if (AnimationClipData.IsClipFinished(sequenceTime, clipData)) { finishedClips.Add(clipData); } else if (!AnimationClipData.IsClipFinished(sequenceTime, clipData) && finishedClips.Contains(clipData)) { finishedClips.Remove(clipData); } } newProcessingClips.Clear(); }
private void SortNewProcessingClips(float sequenceTime) { IOrderedEnumerable <AnimationClipData> orderedEnumerable = from processingClip in this.newProcessingClips orderby processingClip.StartTime select processingClip; foreach (AnimationClipData current in orderedEnumerable) { if (AnimationClipData.IsClipNotRunning(sequenceTime, current)) { this.notRunningClips.Add(current); } else if (!AnimationClipData.IsClipNotRunning(sequenceTime, current) && this.notRunningClips.Contains(current)) { this.notRunningClips.Remove(current); } if (AnimationClipData.IsClipRunning(sequenceTime, current)) { this.runningClips.Add(current); this.PlayClip(current, current.RunningLayer, sequenceTime); } else if (!AnimationClipData.IsClipRunning(sequenceTime, current) && this.runningClips.Contains(current)) { this.runningClips.Remove(current); } if (AnimationClipData.IsClipFinished(sequenceTime, current)) { this.finishedClips.Add(current); } else if (!AnimationClipData.IsClipFinished(sequenceTime, current) && this.finishedClips.Contains(current)) { this.finishedClips.Remove(current); } } this.newProcessingClips.Clear(); }
public static bool IsClipFinished(float sequencerTime, AnimationClipData clipData) { return(sequencerTime >= clipData.EndTime); }
public static bool IsClipRunning(float sequencerTime, AnimationClipData clipData) { return(sequencerTime > clipData.StartTime && sequencerTime < clipData.EndTime); }
public void Process(float sequenceTime, float playbackRate) { allClips.Clear(); for (var index = 0; index < AnimationTimeline.AnimationTracks.Count; index++) { var track = AnimationTimeline.AnimationTracks[index]; for (var trackClipIndex = 0; trackClipIndex < track.TrackClips.Count; trackClipIndex++) { var trackClip = track.TrackClips[trackClipIndex]; allClips.Add(trackClip); trackClip.RunningLayer = track.Layer; } } var totalDeltaTime = sequenceTime - previousTime; var absDeltaTime = Mathf.Abs(totalDeltaTime); var timelinePlayingInReverse = totalDeltaTime < 0.0f; var runningTime = USSequencer.SequenceUpdateRate; var runningTotalTime = previousTime + runningTime; if (timelinePlayingInReverse) { AnimationTimeline.ResetAnimation(); previousTime = 0.0f; AnimationTimeline.Process(sequenceTime, playbackRate); } else { while (absDeltaTime > 0.0f) { cachedRunningClips.Clear(); for (var allClipIndex = 0; allClipIndex < allClips.Count; allClipIndex++) { var clip = allClips[allClipIndex]; if (!AnimationClipData.IsClipRunning(runningTotalTime, clip)) { continue; } cachedRunningClips.Add(clip); } cachedRunningClips.Sort((x, y) => x.StartTime.CompareTo(y.StartTime)); for (var runningClipIndex = 0; runningClipIndex < cachedRunningClips.Count; runningClipIndex++) { var clip = cachedRunningClips[runningClipIndex]; PlayClip(clip, clip.RunningLayer, runningTotalTime); } Animator.Update(runningTime); absDeltaTime -= USSequencer.SequenceUpdateRate; if (!Mathf.Approximately(absDeltaTime, Mathf.Epsilon) && absDeltaTime < USSequencer.SequenceUpdateRate) { runningTime = absDeltaTime; } runningTotalTime += runningTime; } } previousTime = sequenceTime; }