1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #ifndef INTERPOLATOR_H
17 #define INTERPOLATOR_H
18 
19 #include <stddef.h>
20 #include <memory>
21 
22 #include <cutils/compiler.h>
23 #include <vector>
24 
25 namespace android {
26 namespace uirenderer {
27 
28 class Interpolator {
29 public:
~Interpolator()30     virtual ~Interpolator() {}
31 
32     virtual float interpolate(float input) = 0;
33 
34     static Interpolator* createDefaultInterpolator();
35 
36 protected:
Interpolator()37     Interpolator() {}
38 };
39 
40 class ANDROID_API AccelerateDecelerateInterpolator : public Interpolator {
41 public:
42     virtual float interpolate(float input) override;
43 };
44 
45 class ANDROID_API AccelerateInterpolator : public Interpolator {
46 public:
AccelerateInterpolator(float factor)47     explicit AccelerateInterpolator(float factor) : mFactor(factor), mDoubleFactor(factor*2) {}
48     virtual float interpolate(float input) override;
49 private:
50     const float mFactor;
51     const float mDoubleFactor;
52 };
53 
54 class ANDROID_API AnticipateInterpolator : public Interpolator {
55 public:
AnticipateInterpolator(float tension)56     explicit AnticipateInterpolator(float tension) : mTension(tension) {}
57     virtual float interpolate(float input) override;
58 private:
59     const float mTension;
60 };
61 
62 class ANDROID_API AnticipateOvershootInterpolator : public Interpolator {
63 public:
AnticipateOvershootInterpolator(float tension)64     explicit AnticipateOvershootInterpolator(float tension) : mTension(tension) {}
65     virtual float interpolate(float input) override;
66 private:
67     const float mTension;
68 };
69 
70 class ANDROID_API BounceInterpolator : public Interpolator {
71 public:
72     virtual float interpolate(float input) override;
73 };
74 
75 class ANDROID_API CycleInterpolator : public Interpolator {
76 public:
CycleInterpolator(float cycles)77     explicit CycleInterpolator(float cycles) : mCycles(cycles) {}
78     virtual float interpolate(float input) override;
79 private:
80     const float mCycles;
81 };
82 
83 class ANDROID_API DecelerateInterpolator : public Interpolator {
84 public:
DecelerateInterpolator(float factor)85     explicit DecelerateInterpolator(float factor) : mFactor(factor) {}
86     virtual float interpolate(float input) override;
87 private:
88     const float mFactor;
89 };
90 
91 class ANDROID_API LinearInterpolator : public Interpolator {
92 public:
interpolate(float input)93     virtual float interpolate(float input) override { return input; }
94 };
95 
96 class ANDROID_API OvershootInterpolator : public Interpolator {
97 public:
OvershootInterpolator(float tension)98     explicit OvershootInterpolator(float tension) : mTension(tension) {}
99     virtual float interpolate(float input) override;
100 private:
101     const float mTension;
102 };
103 
104 class ANDROID_API PathInterpolator : public Interpolator {
105 public:
PathInterpolator(std::vector<float> && x,std::vector<float> && y)106     explicit PathInterpolator(std::vector<float>&& x, std::vector<float>&& y)
107             : mX (x), mY(y) {}
108     virtual float interpolate(float input) override;
109 private:
110     std::vector<float> mX;
111     std::vector<float> mY;
112 };
113 
114 class ANDROID_API LUTInterpolator : public Interpolator {
115 public:
116     LUTInterpolator(float* values, size_t size);
117     ~LUTInterpolator();
118 
119     virtual float interpolate(float input) override;
120 
121 private:
122     std::unique_ptr<float[]> mValues;
123     size_t mSize;
124 };
125 
126 } /* namespace uirenderer */
127 } /* namespace android */
128 
129 #endif /* INTERPOLATOR_H */
130