universal-tween-engine-cpp/Tween.h at master · kleemedia/universal-tween-engine-cpp · 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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
//
//  Tween.h
//
//  This code is derived from Universal Tween Engine
//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
//

#ifndef __Tween__
#define __Tween__

#include <functional>
#include "BaseTween.h"
#include "Pool.h"
#include "TweenEquation.h"
#include "TweenPath.h"
#include "TweenEquations.h"
#include "TweenPaths.h"

using TweenAccessor = std::function<int(int, float *)>;

namespace TweenEngine
{
    class TweenPool;
    class TweenPoolCallback;

    class Tween : public BaseTween
    {
        friend class TweenPoolCallback;

    private:
        static int combinedAttrsLimit;
        static int waypointsLimit;

        // Main
		TweenAccessor accessor;
		TweenHandle tweenHandle;
		TweenEquation *equation;
        TweenPath *pathAlgorithm;

        // General
        bool isFrom;
        bool isRelative;
        int combinedAttrsCnt;
        int waypointsCnt;

        // Values
        float* startValues;
        float* targetValues;
        float* waypoints;

        // Buffers
        float *accessorBuffer;
        int accessorBufferSize;
        float *pathBuffer;
        int pathBufferSize;

        static TweenPool &pool;

        void setup(TweenHandle tweenHandle, float duration, TweenAccessor accessor);

    protected:
        virtual void reset();
        virtual void forceStartValues();
        virtual void forceEndValues();
        virtual bool containsTarget(TweenHandle tweenHandle);
        virtual void initializeOverride();
        virtual void updateOverride(int step, int lastStep, bool isIterationStep, float delta);

    public:
        static const int ACCESSOR_READ = 0;
        static const int ACCESSOR_WRITE = 1;

        static void setCombinedAttributesLimit(int limit);
        static void setWaypointsLimit(int limit);
        static const char *getVersion();

        static size_t getPoolSize();
        static void ensurePoolCapacity(int minCapacity);

        static Tween &to(TweenHandle tweenHandle, float duration, TweenAccessor accessor);
        static Tween &from(TweenHandle tweenHandle, float duration, TweenAccessor accessor);
        static Tween &set(TweenHandle tweenHandle, TweenAccessor accessor);
        static Tween &call(TweenCallback &callback);
        static Tween &mark();

        Tween();
        ~Tween();

        virtual int getTweenCount();
        virtual int getTimelineCount();

        virtual Tween &build();
        virtual void free();

        Tween &ease(TweenEquation &easeEquation);
        Tween &target(float targetValue);
        Tween &target(float targetValue1, float targetValue2);
        Tween &target(float targetValue1, float targetValue2, float targetValue3);
        Tween &target(float *targetValues, int len);
        Tween &targetRelative(float targetValue);
        Tween &targetRelative(float targetValue1, float targetValue2);
        Tween &targetRelative(float targetValue1, float targetValue2, float targetValue3);
        Tween &targetRelative(float *targetValues, int len);
        Tween &waypoint(float targetValue);
        Tween &waypoint(float targetValue1, float targetValue2);
        Tween &waypoint(float targetValue1, float targetValue2, float targetValue3);
        Tween &waypoint(float *targetValues, int len);
        Tween &path(TweenPath &path);
        TweenEquation *getEasing();
		TweenHandle getHandle();
        float *getTargetValues();
        int getCombinedAttributesCount();


    };
}

#endif /* defined(__Tween__) */