OSharp.Animation/TransformableObject.cs at master · Coosu/OSharp.Animation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
using System;
using System.Collections.Generic;
using System.Linq;

namespace OSharp.Animation
{
    public abstract class TransformableObject<T> where T : struct
    {
        protected abstract void FadeAction(List<TransformAction> actions);
        protected abstract void RotateAction(List<TransformAction> actions);
        protected abstract void MoveAction(List<TransformAction> actions);
        protected abstract void Move1DAction(List<TransformAction> actions, bool isHorizon);
        protected abstract void ScaleVecAction(List<TransformAction> actions);
        protected abstract void ColorAction(List<TransformAction> actions);
        protected abstract void BlendAction(List<TransformAction> actions);
        protected abstract void FlipAction(List<TransformAction> actions);

        protected abstract void HandleLoopGroup((double startTime, int loopTimes, ITransformable<T> transformList) tuple);

        protected abstract void StartAnimation();
        protected abstract void EndAnimation();
        public void ApplyAnimation(Action<ITransformable<T>> func)
        {
            StartAnimation();
            var internalObj = new InternalTransformableObject<T>();
            func?.Invoke(internalObj);
            var time1 = internalObj.TransformDictionary.Count > 0
                ? internalObj.TransformDictionary.Min(k => k.Value.Min(o => o.StartTime))
                : double.MaxValue;
            var time2 = internalObj.loopList.Count > 0
                ? internalObj.loopList.Min(k => k.startTime)
                : double.MaxValue;

            var time3 = internalObj.TransformDictionary.Count > 0
                ? internalObj.TransformDictionary.Max(k => k.Value.Max(o => o.EndTime))
                : double.MinValue;
            var time4 = internalObj.loopList.Count > 0
                ? internalObj.loopList.Max(k =>
                    k.transformList.TransformDictionary.Max(o => o.Value.Max(s => s.EndTime)))
                : double.MinValue;
            MinTime = Math.Min(time1, time2);
            MaxTime = Math.Max(time3, time4);

            foreach (var transform in internalObj.TransformDictionary)
            {
                switch (transform.Key)
                {
                    case TransformType.Fade:
                        FadeAction(transform.Value);
                        break;
                    case TransformType.Rotate:
                        RotateAction(transform.Value);
                        break;
                    case TransformType.Move:
                        MoveAction(transform.Value);
                        break;
                    case TransformType.MoveX:
                        Move1DAction(transform.Value, true);
                        break;
                    case TransformType.MoveY:
                        Move1DAction(transform.Value, false);
                        break;
                    case TransformType.ScaleVec:
                        ScaleVecAction(transform.Value);
                        break;
                    case TransformType.Color:
                        ColorAction(transform.Value);
                        break;
                    case TransformType.Blend:
                        BlendAction(transform.Value);
                        break;
                    case TransformType.Flip:
                        FlipAction(transform.Value);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            foreach (var tuple in internalObj.loopList)
            {
                HandleLoopGroup(tuple);
            }

            EndAnimation();
        }

        public double MaxTime { get; set; }

        public double MinTime { get; set; }
    }
}