Example #1
0
        protected override void CopyData(BaseEvent src)
        {
            base.CopyData(src);
            DurationEvent event2 = src as DurationEvent;

            this.length = event2.length;
        }
        public void ResetLength(int inLengthMs, bool bPlaySpeed)
        {
            if (this.length <= 0 || inLengthMs == 0)
            {
                return;
            }
            bool flag  = true;
            bool flag2 = true;

            if (inLengthMs < 0)
            {
                inLengthMs = 1073741823;
                flag       = true;
                flag2      = false;
            }
            VFactor f = new VFactor((long)inLengthMs, (long)this.length);

            if (bPlaySpeed)
            {
                this.SetPlaySpeed(f.Inverse);
                return;
            }
            this.length *= f;
            int count = this.tracks.Count;

            for (int i = 0; i < count; i++)
            {
                Track track = this.tracks[i];
                if (track != null)
                {
                    int count2 = track.trackEvents.get_Count();
                    for (int j = 0; j < count2; j++)
                    {
                        BaseEvent baseEvent = track.trackEvents.get_Item(j);
                        if (baseEvent != null)
                        {
                            DurationEvent durationEvent = baseEvent as DurationEvent;
                            if (durationEvent != null)
                            {
                                if (flag2 && durationEvent.bScaleStart)
                                {
                                    durationEvent.time *= f;
                                }
                                if (durationEvent.time > track.Length)
                                {
                                    durationEvent.time = track.Length;
                                }
                                if (flag && durationEvent.bScaleLength)
                                {
                                    durationEvent.length *= f;
                                }
                                if (durationEvent.End > track.Length)
                                {
                                    durationEvent.End = track.Length;
                                }
                            }
                            else
                            {
                                if (flag2 && baseEvent.bScaleStart)
                                {
                                    baseEvent.time *= f;
                                }
                                if (baseEvent.time > track.Length)
                                {
                                    baseEvent.time = track.Length;
                                }
                            }
                        }
                    }
                }
            }
        }
        public void Process(int _curTime)
        {
            this.preExcuteTime = this.curTime;
            this.curTime       = _curTime;
            int num = 0;

            if (!this.LocateEvent(_curTime, out num) || num < 0)
            {
                return;
            }
            int length = this.Length;

            if (_curTime >= length)
            {
                num = this.trackEvents.get_Count() - 1;
            }
            int num2 = num - 1;

            if (num2 < 0)
            {
                num2 = 0;
            }
            int num3 = num + 1;

            if (num3 >= this.trackEvents.get_Count())
            {
                num3 = num;
            }
            if (this.isDurationEvent)
            {
                for (int i = num2; i < this.trackEvents.get_Count(); i++)
                {
                    DurationEvent durationEvent = this.trackEvents.get_Item(i) as DurationEvent;
                    if (this.CheckSkip(_curTime, durationEvent.Start) && durationEvent.CheckConditions(this.action))
                    {
                        if (this.activeEvents.get_Count() == 0)
                        {
                            durationEvent.Enter(this.action, this);
                        }
                        else
                        {
                            DurationEvent durationEvent2 = this.activeEvents.get_Item(0);
                            int           blendTime      = durationEvent2.End - durationEvent.Start;
                            durationEvent.EnterBlend(this.action, this, durationEvent2, blendTime);
                        }
                        this.activeEvents.Add(durationEvent);
                    }
                    if (this.CheckSkip(_curTime, durationEvent.End) && this.activeEvents.Contains(durationEvent))
                    {
                        if (this.activeEvents.get_Count() > 1)
                        {
                            DurationEvent durationEvent3 = this.activeEvents.get_Item(1);
                            int           blendTime2     = durationEvent.End - durationEvent3.Start;
                            durationEvent.LeaveBlend(this.action, this, durationEvent3, blendTime2);
                        }
                        else
                        {
                            durationEvent.Leave(this.action, this);
                        }
                        this.activeEvents.Remove(durationEvent);
                    }
                }
            }
            else
            {
                for (int j = num2; j < this.trackEvents.get_Count(); j++)
                {
                    TickEvent tickEvent = this.trackEvents.get_Item(j) as TickEvent;
                    if (this.CheckSkip(_curTime, tickEvent.time) && tickEvent.CheckConditions(this.action))
                    {
                        tickEvent.Process(this.action, this);
                    }
                }
                if (num != num3)
                {
                    TickEvent tickEvent2  = this.trackEvents.get_Item(num) as TickEvent;
                    TickEvent tickEvent3  = this.trackEvents.get_Item(num3) as TickEvent;
                    float     blendWeight = (float)(_curTime - tickEvent2.time) / (float)(tickEvent3.time - tickEvent2.time);
                    tickEvent3.ProcessBlend(this.action, this, tickEvent2, blendWeight);
                }
                else
                {
                    TickEvent tickEvent4 = this.trackEvents.get_Item(num) as TickEvent;
                    int       localTime  = _curTime - tickEvent4.time;
                    tickEvent4.PostProcess(this.action, this, localTime);
                }
            }
            if (this.activeEvents.get_Count() == 1)
            {
                DurationEvent durationEvent4 = this.activeEvents.get_Item(0);
                int           localTime2;
                if (_curTime >= durationEvent4.Start)
                {
                    localTime2 = _curTime - durationEvent4.Start;
                }
                else
                {
                    localTime2 = _curTime + length - durationEvent4.Start;
                }
                durationEvent4.Process(this.action, this, localTime2);
            }
            else if (this.activeEvents.get_Count() == 2)
            {
                DurationEvent durationEvent5 = this.activeEvents.get_Item(0);
                DurationEvent durationEvent6 = this.activeEvents.get_Item(1);
                if (durationEvent5.Start < durationEvent6.Start && durationEvent5.End < length)
                {
                    int   localTime3    = _curTime - durationEvent6.Start;
                    int   prevLocalTime = _curTime - durationEvent5.Start;
                    float blendWeight2  = (float)(_curTime - durationEvent6.Start) / (float)(durationEvent5.End - durationEvent6.Start);
                    durationEvent6.ProcessBlend(this.action, this, localTime3, durationEvent5, prevLocalTime, blendWeight2);
                }
                else if (durationEvent5.Start < durationEvent6.Start && durationEvent5.End >= length)
                {
                    if (_curTime >= durationEvent6.Start)
                    {
                        int   localTime4     = _curTime - durationEvent6.Start;
                        int   prevLocalTime2 = _curTime - durationEvent5.Start;
                        float blendWeight3   = (float)(_curTime - durationEvent6.Start) / (float)(durationEvent5.End - durationEvent6.Start);
                        durationEvent6.ProcessBlend(this.action, this, localTime4, durationEvent5, prevLocalTime2, blendWeight3);
                    }
                    else
                    {
                        int   localTime5     = _curTime + length - durationEvent6.Start;
                        int   prevLocalTime3 = _curTime + length - durationEvent5.Start;
                        float blendWeight4   = (float)(_curTime + length - durationEvent6.Start) / (float)(durationEvent5.End - durationEvent6.Start);
                        durationEvent6.ProcessBlend(this.action, this, localTime5, durationEvent5, prevLocalTime3, blendWeight4);
                    }
                }
                else
                {
                    int   localTime6     = _curTime - durationEvent6.Start;
                    int   prevLocalTime4 = _curTime + length - durationEvent5.Start;
                    float blendWeight5   = (float)(_curTime - durationEvent6.Start) / (float)(durationEvent5.End - length - durationEvent6.Start);
                    durationEvent6.ProcessBlend(this.action, this, localTime6, durationEvent5, prevLocalTime4, blendWeight5);
                }
            }
        }
Example #4
0
 public virtual void ProcessBlend(Action _action, Track _track, int _localTime, DurationEvent _prevEvent, int _prevLocalTime, float _blendWeight)
 {
     if (_prevEvent != null)
     {
         _prevEvent.Process(_action, _track, _prevLocalTime);
     }
     this.Process(_action, _track, _localTime);
 }
Example #5
0
 public void ResetLength(int inLengthMs, bool bPlaySpeed)
 {
     if ((this.length > 0) && (inLengthMs != 0))
     {
         bool flag  = true;
         bool flag2 = true;
         if (inLengthMs < 0)
         {
             inLengthMs = 0x3fffffff;
             flag       = true;
             flag2      = false;
         }
         VFactor factor = new VFactor((long)inLengthMs, (long)this.length);
         if (bPlaySpeed)
         {
             this.SetPlaySpeed(factor.Inverse);
         }
         else
         {
             this.length *= factor;
             int count = this.tracks.Count;
             for (int i = 0; i < count; i++)
             {
                 Track track = this.tracks[i];
                 if (track != null)
                 {
                     int num3 = track.trackEvents.Count;
                     for (int j = 0; j < num3; j++)
                     {
                         BaseEvent event2 = track.trackEvents[j];
                         if (event2 != null)
                         {
                             if (event2.GetType().IsSubclassOf(typeof(DurationEvent)))
                             {
                                 DurationEvent event3 = event2 as DurationEvent;
                                 if (flag2 && event3.bScaleStart)
                                 {
                                     event3.time *= factor;
                                 }
                                 if (event3.time > track.Length)
                                 {
                                     event3.time = track.Length;
                                 }
                                 if (flag && event3.bScaleLength)
                                 {
                                     event3.length *= factor;
                                 }
                                 if (event3.End > track.Length)
                                 {
                                     event3.End = track.Length;
                                 }
                             }
                             else
                             {
                                 if (flag2 && event2.bScaleStart)
                                 {
                                     event2.time *= factor;
                                 }
                                 if (event2.time > track.Length)
                                 {
                                     event2.time = track.Length;
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 }
Example #6
0
        public void Process(int _curTime)
        {
            this.preExcuteTime = this.curTime;
            this.curTime       = _curTime;
            int num = 0;

            if (this.LocateEvent(_curTime, out num) && (num >= 0))
            {
                int length = this.Length;
                if ((_curTime >= length) && !this.Loop)
                {
                    num = this.trackEvents.Count - 1;
                }
                if (this.Loop)
                {
                    int num3 = ((num - 1) + this.trackEvents.Count) % this.trackEvents.Count;
                    int num4 = ((num + 1) + this.trackEvents.Count) % this.trackEvents.Count;
                    if (this.isDurationEvent)
                    {
                        int num5 = num3;
                        for (int i = 0; i < this.trackEvents.Count; i++)
                        {
                            DurationEvent item = this.trackEvents[num5] as DurationEvent;
                            if (this.CheckSkip(_curTime, item.Start) && item.CheckConditions(this.action))
                            {
                                if (this.activeEvents.Count == 0)
                                {
                                    item.Enter(this.action, this);
                                }
                                else
                                {
                                    DurationEvent event3 = this.activeEvents[0];
                                    if ((event3.Start < item.Start) && (event3.End < length))
                                    {
                                        int num7 = event3.End - item.Start;
                                        item.EnterBlend(this.action, this, event3, num7);
                                    }
                                    else if ((event3.Start < item.Start) && (event3.End >= length))
                                    {
                                        int num8 = event3.End - item.Start;
                                        item.EnterBlend(this.action, this, event3, num8);
                                    }
                                    else
                                    {
                                        int num9 = (event3.End - length) - item.Start;
                                        item.EnterBlend(this.action, this, event3, num9);
                                    }
                                }
                                this.activeEvents.Add(item);
                            }
                            if (this.CheckSkip(_curTime, item.End) && this.activeEvents.Contains(item))
                            {
                                item.Leave(this.action, this);
                                this.activeEvents.Remove(item);
                            }
                            num5 = (num5 + 1) % this.trackEvents.Count;
                        }
                    }
                    else
                    {
                        int num10 = num3;
                        for (int j = 0; j < this.trackEvents.Count; j++)
                        {
                            TickEvent event4 = this.trackEvents[num10] as TickEvent;
                            if (this.CheckSkip(_curTime, event4.time) && event4.CheckConditions(this.action))
                            {
                                event4.Process(this.action, this);
                            }
                            num10 = (num10 + 1) % this.trackEvents.Count;
                        }
                        if (num != num4)
                        {
                            TickEvent event5 = this.trackEvents[num] as TickEvent;
                            TickEvent event6 = this.trackEvents[num4] as TickEvent;
                            if (event6.time > event5.time)
                            {
                                float num12 = ((float)(_curTime - event5.time)) / ((float)(event6.time - event5.time));
                                event6.ProcessBlend(this.action, this, event5, num12);
                            }
                            else if (event6.time < event5.time)
                            {
                                if (_curTime >= event5.time)
                                {
                                    float num13 = ((float)(_curTime - event5.time)) / ((float)((event6.time + length) - event5.time));
                                    event6.ProcessBlend(this.action, this, event5, num13);
                                }
                                else
                                {
                                    float num14 = ((float)((_curTime + length) - event5.time)) / ((float)((event6.time + length) - event5.time));
                                    event6.ProcessBlend(this.action, this, event5, num14);
                                }
                            }
                        }
                        else
                        {
                            TickEvent event7 = this.trackEvents[num] as TickEvent;
                            if (_curTime > event7.time)
                            {
                                int num15 = _curTime - event7.time;
                                event7.PostProcess(this.action, this, num15);
                            }
                            else if (_curTime < event7.time)
                            {
                                if (_curTime >= event7.time)
                                {
                                    int num16 = _curTime - event7.time;
                                    event7.PostProcess(this.action, this, num16);
                                }
                                else
                                {
                                    int num17 = (_curTime + length) - event7.time;
                                    event7.PostProcess(this.action, this, num17);
                                }
                            }
                        }
                    }
                }
                else
                {
                    int num18 = num - 1;
                    if (num18 < 0)
                    {
                        num18 = 0;
                    }
                    int num19 = num + 1;
                    if (num19 >= this.trackEvents.Count)
                    {
                        num19 = num;
                    }
                    if (this.isDurationEvent)
                    {
                        for (int k = num18; k < this.trackEvents.Count; k++)
                        {
                            DurationEvent event8 = this.trackEvents[k] as DurationEvent;
                            if (this.CheckSkip(_curTime, event8.Start) && event8.CheckConditions(this.action))
                            {
                                if (this.activeEvents.Count == 0)
                                {
                                    event8.Enter(this.action, this);
                                }
                                else
                                {
                                    DurationEvent event9 = this.activeEvents[0];
                                    int           num21  = event9.End - event8.Start;
                                    event8.EnterBlend(this.action, this, event9, num21);
                                }
                                this.activeEvents.Add(event8);
                            }
                            if (this.CheckSkip(_curTime, event8.End) && this.activeEvents.Contains(event8))
                            {
                                if (this.activeEvents.Count > 1)
                                {
                                    DurationEvent event10 = this.activeEvents[1];
                                    int           num22   = event8.End - event10.Start;
                                    event8.LeaveBlend(this.action, this, event10, num22);
                                }
                                else
                                {
                                    event8.Leave(this.action, this);
                                }
                                this.activeEvents.Remove(event8);
                            }
                        }
                    }
                    else
                    {
                        for (int m = num18; m < this.trackEvents.Count; m++)
                        {
                            TickEvent event11 = this.trackEvents[m] as TickEvent;
                            if (this.CheckSkip(_curTime, event11.time) && event11.CheckConditions(this.action))
                            {
                                event11.Process(this.action, this);
                            }
                        }
                        if (num != num19)
                        {
                            TickEvent event12 = this.trackEvents[num] as TickEvent;
                            TickEvent event13 = this.trackEvents[num19] as TickEvent;
                            float     num24   = ((float)(_curTime - event12.time)) / ((float)(event13.time - event12.time));
                            event13.ProcessBlend(this.action, this, event12, num24);
                        }
                        else
                        {
                            TickEvent event14 = this.trackEvents[num] as TickEvent;
                            int       num25   = _curTime - event14.time;
                            event14.PostProcess(this.action, this, num25);
                        }
                    }
                }
                if (this.activeEvents.Count == 1)
                {
                    DurationEvent event15 = this.activeEvents[0];
                    int           num26   = 0;
                    if (_curTime >= event15.Start)
                    {
                        num26 = _curTime - event15.Start;
                    }
                    else
                    {
                        num26 = (_curTime + length) - event15.Start;
                    }
                    event15.Process(this.action, this, num26);
                }
                else if (this.activeEvents.Count == 2)
                {
                    DurationEvent event16 = this.activeEvents[0];
                    DurationEvent event17 = this.activeEvents[1];
                    if ((event16.Start < event17.Start) && (event16.End < length))
                    {
                        int   num27 = _curTime - event17.Start;
                        int   num28 = _curTime - event16.Start;
                        float num29 = ((float)(_curTime - event17.Start)) / ((float)(event16.End - event17.Start));
                        event17.ProcessBlend(this.action, this, num27, event16, num28, num29);
                    }
                    else if ((event16.Start < event17.Start) && (event16.End >= length))
                    {
                        if (_curTime >= event17.Start)
                        {
                            int   num30 = _curTime - event17.Start;
                            int   num31 = _curTime - event16.Start;
                            float num32 = ((float)(_curTime - event17.Start)) / ((float)(event16.End - event17.Start));
                            event17.ProcessBlend(this.action, this, num30, event16, num31, num32);
                        }
                        else
                        {
                            int   num33 = (_curTime + length) - event17.Start;
                            int   num34 = (_curTime + length) - event16.Start;
                            float num35 = ((float)((_curTime + length) - event17.Start)) / ((float)(event16.End - event17.Start));
                            event17.ProcessBlend(this.action, this, num33, event16, num34, num35);
                        }
                    }
                    else
                    {
                        int   num36 = _curTime - event17.Start;
                        int   num37 = (_curTime + length) - event16.Start;
                        float num38 = ((float)(_curTime - event17.Start)) / ((float)((event16.End - length) - event17.Start));
                        event17.ProcessBlend(this.action, this, num36, event16, num37, num38);
                    }
                }
            }
        }