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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
#define UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
#include <stddef.h>
#include <memory>
#include <vector>
#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
#include "ui/gfx/geometry/cubic_bezier.h"
namespace gfx {
// See http://www.w3.org/TR/css3-transitions/.
class GFX_KEYFRAME_ANIMATION_EXPORT TimingFunction {
public:
virtual ~TimingFunction();
TimingFunction& operator=(const TimingFunction&) = delete;
// Note that LINEAR is a nullptr TimingFunction (for now).
enum class Type { LINEAR, CUBIC_BEZIER, STEPS };
// Which limit to apply at a discontinuous boundary.
// See https://drafts.csswg.org/css-easing/#step-easing-algo
enum class LimitDirection { LEFT, RIGHT };
virtual Type GetType() const = 0;
virtual double GetValue(double t, LimitDirection limit_direction) const = 0;
virtual double Velocity(double time) const = 0;
virtual std::unique_ptr<TimingFunction> Clone() const = 0;
protected:
TimingFunction();
};
class GFX_KEYFRAME_ANIMATION_EXPORT CubicBezierTimingFunction
: public TimingFunction {
public:
enum class EaseType { EASE, EASE_IN, EASE_OUT, EASE_IN_OUT, CUSTOM };
static std::unique_ptr<CubicBezierTimingFunction> CreatePreset(
EaseType ease_type);
static std::unique_ptr<CubicBezierTimingFunction> Create(double x1,
double y1,
double x2,
double y2);
~CubicBezierTimingFunction() override;
CubicBezierTimingFunction& operator=(const CubicBezierTimingFunction&) =
delete;
// TimingFunction implementation.
Type GetType() const override;
double GetValue(
double time,
LimitDirection limit_direction = LimitDirection::RIGHT) const override;
double Velocity(double time) const override;
std::unique_ptr<TimingFunction> Clone() const override;
EaseType ease_type() const { return ease_type_; }
const gfx::CubicBezier& bezier() const { return bezier_; }
private:
CubicBezierTimingFunction(EaseType ease_type,
double x1,
double y1,
double x2,
double y2);
gfx::CubicBezier bezier_;
EaseType ease_type_;
};
class GFX_KEYFRAME_ANIMATION_EXPORT StepsTimingFunction
: public TimingFunction {
public:
// step-timing-function values
// https://drafts.csswg.org/css-easing-1/#typedef-step-timing-function
enum class StepPosition {
START, // Discontinuity at progress = 0.
// Alias for jump-start. Maintaining a separate enumerated value
// for serialization.
END, // Discontinuity at progress = 1.
// Alias for jump-end. Maintaining a separate enumerated value
// for serialization.
JUMP_BOTH, // Discontinuities at progress = 0 and 1.
JUMP_END, // Discontinuity at progress = 1.
JUMP_NONE, // Continuous at progress = 0 and 1.
JUMP_START // Discontinuity at progress = 0.
};
static std::unique_ptr<StepsTimingFunction> Create(
int steps,
StepPosition step_position);
~StepsTimingFunction() override;
StepsTimingFunction& operator=(const StepsTimingFunction&) = delete;
// TimingFunction implementation.
Type GetType() const override;
double GetValue(double t, LimitDirection limit_direction) const override;
std::unique_ptr<TimingFunction> Clone() const override;
double Velocity(double time) const override;
int steps() const { return steps_; }
StepPosition step_position() const { return step_position_; }
private:
StepsTimingFunction(int steps, StepPosition step_position);
// The number of jumps is the number of discontinuities in the timing
// function. There is a subtle distinction between the number of steps and
// jumps. The number of steps is the number of intervals in the timing
// function. The number of jumps differs from the number of steps when either
// both or neither end point has a discontinuity.
// https://drafts.csswg.org/css-easing-1/#step-easing-functions
int NumberOfJumps() const;
float GetStepsStartOffset() const;
int steps_;
StepPosition step_position_;
};
struct GFX_KEYFRAME_ANIMATION_EXPORT LinearEasingPoint {
double input;
double output;
LinearEasingPoint() = default;
LinearEasingPoint(double input, double output) {
this->input = input;
this->output = output;
}
friend bool operator==(const LinearEasingPoint&,
const LinearEasingPoint&) = default;
};
class GFX_KEYFRAME_ANIMATION_EXPORT LinearTimingFunction
: public TimingFunction {
public:
static std::unique_ptr<LinearTimingFunction> Create();
static std::unique_ptr<LinearTimingFunction> Create(
std::vector<LinearEasingPoint> points);
LinearTimingFunction& operator=(const LinearTimingFunction&) = delete;
~LinearTimingFunction() override;
// TimingFunction implementation.
Type GetType() const override;
double GetValue(
double t,
LimitDirection limit_direction = LimitDirection::RIGHT) const override;
std::unique_ptr<TimingFunction> Clone() const override;
double Velocity(double time) const override;
const LinearEasingPoint& Point(size_t i) const { return points_[i]; }
const std::vector<LinearEasingPoint>& Points() const { return points_; }
bool IsTrivial() const { return !points_.size(); }
private:
LinearTimingFunction();
explicit LinearTimingFunction(std::vector<LinearEasingPoint> points);
LinearTimingFunction(const LinearTimingFunction&);
std::vector<LinearEasingPoint> points_;
};
} // namespace gfx
#endif // UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
|
