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
25namespace android {
26namespace uirenderer {
27
28class Interpolator {
29public:
30    virtual ~Interpolator() {}
31
32    virtual float interpolate(float input) = 0;
33
34    static Interpolator* createDefaultInterpolator();
35
36protected:
37    Interpolator() {}
38};
39
40class ANDROID_API AccelerateDecelerateInterpolator : public Interpolator {
41public:
42    virtual float interpolate(float input) override;
43};
44
45class ANDROID_API AccelerateInterpolator : public Interpolator {
46public:
47    explicit AccelerateInterpolator(float factor) : mFactor(factor), mDoubleFactor(factor*2) {}
48    virtual float interpolate(float input) override;
49private:
50    const float mFactor;
51    const float mDoubleFactor;
52};
53
54class ANDROID_API AnticipateInterpolator : public Interpolator {
55public:
56    explicit AnticipateInterpolator(float tension) : mTension(tension) {}
57    virtual float interpolate(float input) override;
58private:
59    const float mTension;
60};
61
62class ANDROID_API AnticipateOvershootInterpolator : public Interpolator {
63public:
64    explicit AnticipateOvershootInterpolator(float tension) : mTension(tension) {}
65    virtual float interpolate(float input) override;
66private:
67    const float mTension;
68};
69
70class ANDROID_API BounceInterpolator : public Interpolator {
71public:
72    virtual float interpolate(float input) override;
73};
74
75class ANDROID_API CycleInterpolator : public Interpolator {
76public:
77    explicit CycleInterpolator(float cycles) : mCycles(cycles) {}
78    virtual float interpolate(float input) override;
79private:
80    const float mCycles;
81};
82
83class ANDROID_API DecelerateInterpolator : public Interpolator {
84public:
85    explicit DecelerateInterpolator(float factor) : mFactor(factor) {}
86    virtual float interpolate(float input) override;
87private:
88    const float mFactor;
89};
90
91class ANDROID_API LinearInterpolator : public Interpolator {
92public:
93    virtual float interpolate(float input) override { return input; }
94};
95
96class ANDROID_API OvershootInterpolator : public Interpolator {
97public:
98    explicit OvershootInterpolator(float tension) : mTension(tension) {}
99    virtual float interpolate(float input) override;
100private:
101    const float mTension;
102};
103
104class ANDROID_API PathInterpolator : public Interpolator {
105public:
106    explicit PathInterpolator(std::vector<float>&& x, std::vector<float>&& y)
107            : mX (x), mY(y) {}
108    virtual float interpolate(float input) override;
109private:
110    std::vector<float> mX;
111    std::vector<float> mY;
112};
113
114class ANDROID_API LUTInterpolator : public Interpolator {
115public:
116    LUTInterpolator(float* values, size_t size);
117    ~LUTInterpolator();
118
119    virtual float interpolate(float input) override;
120
121private:
122    std::unique_ptr<float[]> mValues;
123    size_t mSize;
124};
125
126} /* namespace uirenderer */
127} /* namespace android */
128
129#endif /* INTERPOLATOR_H */
130