private void Evaluate(Playable playable, FrameData frameData) { if (this.m_IntervalTree != null) { double time = PlayableExtensions.GetTime <Playable>(playable); this.m_ActiveBit = ((this.m_ActiveBit != 0) ? 0 : 1); this.m_CurrentListOfActiveClips.Clear(); this.m_IntervalTree.IntersectsWith(DiscreteTime.GetNearestTick(time), this.m_ActiveBit, ref this.m_CurrentListOfActiveClips); for (int i = 0; i < this.m_ActiveClips.Count; i++) { RuntimeElement runtimeElement = this.m_ActiveClips[i]; if (runtimeElement.intervalBit != this.m_ActiveBit) { runtimeElement.enable = false; } } for (int j = 0; j < this.m_CurrentListOfActiveClips.Count; j++) { this.m_CurrentListOfActiveClips[j].EvaluateAt(time, frameData); } this.m_ActiveClips.Clear(); this.m_ActiveClips.AddRange(this.m_CurrentListOfActiveClips); int count = this.m_EvaluateCallbacks.Count; for (int k = 0; k < count; k++) { this.m_EvaluateCallbacks[k].Evaluate(); } } }
private void Evaluate(Playable playable, FrameData frameData) { if (m_IntervalTree == null) { return; } double localTime = playable.GetTime(); m_ActiveBit = m_ActiveBit == 0 ? 1 : 0; m_CurrentListOfActiveClips.Clear(); m_IntervalTree.IntersectsWith(DiscreteTime.GetNearestTick(localTime), m_CurrentListOfActiveClips); foreach (var c in m_CurrentListOfActiveClips) { c.intervalBit = m_ActiveBit; if (frameData.timeLooped) { c.Reset(); } } // all previously active clips having a different intervalBit flag are not // in the current intersection, therefore are considered becoming disabled at this frame var timelineEnd = playable.GetDuration(); foreach (var c in m_ActiveClips) { if (c.intervalBit != m_ActiveBit) { var clipEnd = (double)DiscreteTime.FromTicks(c.intervalEnd); var time = frameData.timeLooped ? Math.Min(clipEnd, timelineEnd) : Math.Min(localTime, clipEnd); c.EvaluateAt(time, frameData); c.enable = false; } } m_ActiveClips.Clear(); // case 998642 - don't use m_ActiveClips.AddRange, as in 4.6 .Net scripting it causes GC allocs for (var a = 0; a < m_CurrentListOfActiveClips.Count; a++) { m_CurrentListOfActiveClips[a].EvaluateAt(localTime, frameData); m_ActiveClips.Add(m_CurrentListOfActiveClips[a]); } int count = m_EvaluateCallbacks.Count; for (int i = 0; i < count; i++) { m_EvaluateCallbacks[i].Evaluate(); } }
private void Evaluate(Playable playable, FrameData frameData) { if (m_IntervalTree == null) { return; } double localTime = playable.GetTime(); m_ActiveBit = m_ActiveBit == 0 ? 1 : 0; m_CurrentListOfActiveClips.Clear(); m_IntervalTree.IntersectsWith(DiscreteTime.GetNearestTick(localTime), m_CurrentListOfActiveClips); foreach (var c in m_CurrentListOfActiveClips) { c.intervalBit = m_ActiveBit; } // all previously active clips having a different intervalBit flag are not // in the current intersection, therefore are considered becoming disabled at this frame for (int a = 0; a < m_ActiveClips.Count; a++) { var c = m_ActiveClips[a]; if (c.intervalBit != m_ActiveBit) { // Set time to the latest timeline time before disabling the clip. c.EvaluateAt(localTime, frameData); c.enable = false; } } m_ActiveClips.Clear(); // case 998642 - don't use m_ActiveClips.AddRange, as in 4.6 .Net scripting it causes GC allocs for (int a = 0; a < m_CurrentListOfActiveClips.Count; a++) { m_CurrentListOfActiveClips[a].EvaluateAt(localTime, frameData); m_ActiveClips.Add(m_CurrentListOfActiveClips[a]); } int count = m_EvaluateCallbacks.Count; for (int i = 0; i < count; i++) { m_EvaluateCallbacks[i].Evaluate(); } }
protected internal virtual void UpdateDuration() { int h = (!(this.m_AnimClip != null)) ? 0 : ((int)(this.m_AnimClip.frameRate * this.m_AnimClip.length)); int num = HashUtility.CombineHash(this.GetClipsHash(), this.GetMarkerHash(), h); if (num != this.m_ItemsHash) { this.m_ItemsHash = num; double num2; double num3; this.GetSequenceTime(out num2, out num3); this.m_Start = (DiscreteTime)num2; this.m_End = (DiscreteTime)(num2 + num3); this.CalculateExtrapolationTimes(); } }
private bool CanTriggerEvent(double playableTime, FrameData info) { bool flag = DiscreteTime.GetNearestTick(playableTime) >= DiscreteTime.GetNearestTick(this.triggerTime); bool result; if (flag) { result = true; } else { bool flag2 = this.HasLooped(playableTime, info) && this.triggerTime >= this.m_PreviousTime && this.triggerTime <= this.m_PreviousTime + (double)info.get_deltaTime(); result = flag2; } return(result); }
public override void DisableAt(double localTime, double rootDuration, FrameData frameData) { var time = Math.Min(localTime, (double)DiscreteTime.FromTicks(intervalEnd)); if (frameData.timeLooped) { time = Math.Min(time, rootDuration); } var clipTime = clip.ToLocalTime(time); if (clipTime > -DiscreteTime.tickValue / 2) { SetTime(clipTime); } enable = false; }
void UpdateDuration() { // check if something changed in the clips that require a re-calculation of the evaluation times. var itemsHash = CalculateItemsHash(); if (itemsHash == m_ItemsHash) return; m_ItemsHash = itemsHash; double trackStart, trackDuration; GetSequenceTime(out trackStart, out trackDuration); m_Start = (DiscreteTime)trackStart; m_End = (DiscreteTime)(trackStart + trackDuration); // calculate the extrapolations time. // TODO Extrapolation time should probably be extracted from the SequenceClip so only a track is aware of it. this.CalculateExtrapolationTimes(); }
double CalculateDuration() { var discreteDuration = new DiscreteTime(0); foreach (var track in flattenedTracks) { if (track.muted) { continue; } discreteDuration = DiscreteTime.Max(discreteDuration, (DiscreteTime)track.end); } if (discreteDuration <= 0) { return(0.0); } //avoid having no clip evaluated at the end by removing a tick from the total duration return((double)discreteDuration.OneTickBefore()); }
private double CalculateDuration() { IEnumerable <TrackAsset> flattenedTracks = this.flattenedTracks; DiscreteTime lhs = new DiscreteTime(0); foreach (TrackAsset trackAsset in flattenedTracks) { if (!trackAsset.muted) { lhs = DiscreteTime.Max(lhs, (DiscreteTime)trackAsset.end); } } double result; if (lhs <= 0) { result = 0.0; } else { result = (double)lhs.OneTickBefore(); } return(result); }
public bool Equals(DiscreteTime other) { return(m_DiscreteTime == other.m_DiscreteTime); }
public static long GetNearestTick(double time) { return(DiscreteTime.DoubleToDiscreteTime(time)); }
public DiscreteTime(DiscreteTime time) { m_DiscreteTime = time.m_DiscreteTime; }
public static DiscreteTime Max(DiscreteTime lhs, DiscreteTime rhs) { return(new DiscreteTime(Math.Max(lhs.m_DiscreteTime, rhs.m_DiscreteTime))); }
public DiscreteTime(int frame, double fps) { this.m_DiscreteTime = DiscreteTime.DoubleToDiscreteTime((double)frame * fps); }
private static long IntToDiscreteTime(int time) { return(DiscreteTime.DoubleToDiscreteTime((double)time)); }
public DiscreteTime(int time) { this.m_DiscreteTime = DiscreteTime.IntToDiscreteTime(time); }
public DiscreteTime(float time) { this.m_DiscreteTime = DiscreteTime.FloatToDiscreteTime(time); }
private static float ToFloat(long time) { return((float)DiscreteTime.ToDouble(time)); }
public static double SnapToNearestTick(double time) { long time2 = DiscreteTime.DoubleToDiscreteTime(time); return(DiscreteTime.ToDouble(time2)); }
public static float SnapToNearestTick(float time) { long time2 = DiscreteTime.FloatToDiscreteTime(time); return(DiscreteTime.ToFloat(time2)); }
private bool CanRestoreEvent(double playableTime, FrameData info) { return(DiscreteTime.GetNearestTick(playableTime) < DiscreteTime.GetNearestTick(this.triggerTime)); }
public DiscreteTime(double time) { this.m_DiscreteTime = DiscreteTime.DoubleToDiscreteTime(time); }