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
|
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_ANIMATION_TIMING_FUNCTION_H_
#define CC_ANIMATION_TIMING_FUNCTION_H_
#include <memory>
#include "cc/animation/animation_export.h"
#include "ui/gfx/geometry/cubic_bezier.h"
namespace cc {
// See http://www.w3.org/TR/css3-transitions/.
class CC_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.
enum class LimitDirection { LEFT, RIGHT };
virtual Type GetType() const = 0;
virtual double GetValue(double t) const = 0;
virtual double Velocity(double time) const = 0;
virtual std::unique_ptr<TimingFunction> Clone() const = 0;
protected:
TimingFunction();
};
class CC_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) 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 CC_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) 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_; }
double GetPreciseValue(double t, LimitDirection limit_direction) const;
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_;
};
class CC_ANIMATION_EXPORT LinearTimingFunction : public TimingFunction {
public:
static std::unique_ptr<LinearTimingFunction> Create();
~LinearTimingFunction() override;
// TimingFunction implementation.
Type GetType() const override;
double GetValue(double t) const override;
std::unique_ptr<TimingFunction> Clone() const override;
double Velocity(double time) const override;
private:
LinearTimingFunction();
};
} // namespace cc
#endif // CC_ANIMATION_TIMING_FUNCTION_H_
|
