• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef CC_ANIMATION_KEYFRAMED_ANIMATION_CURVE_H_
6 #define CC_ANIMATION_KEYFRAMED_ANIMATION_CURVE_H_
7 
8 #include "cc/animation/animation_curve.h"
9 #include "cc/animation/timing_function.h"
10 #include "cc/animation/transform_operations.h"
11 #include "cc/base/cc_export.h"
12 #include "cc/base/scoped_ptr_vector.h"
13 
14 namespace cc {
15 
16 class CC_EXPORT Keyframe {
17  public:
18   double Time() const;
timing_function()19   const TimingFunction* timing_function() const {
20     return timing_function_.get();
21   }
22 
23  protected:
24   Keyframe(double time, scoped_ptr<TimingFunction> timing_function);
25   virtual ~Keyframe();
26 
27  private:
28   double time_;
29   scoped_ptr<TimingFunction> timing_function_;
30 
31   DISALLOW_COPY_AND_ASSIGN(Keyframe);
32 };
33 
34 class CC_EXPORT ColorKeyframe : public Keyframe {
35  public:
36   static scoped_ptr<ColorKeyframe> Create(
37       double time,
38       SkColor value,
39       scoped_ptr<TimingFunction> timing_function);
40   virtual ~ColorKeyframe();
41 
42   SkColor Value() const;
43 
44   scoped_ptr<ColorKeyframe> Clone() const;
45 
46  private:
47   ColorKeyframe(double time,
48                 SkColor value,
49                 scoped_ptr<TimingFunction> timing_function);
50 
51   SkColor value_;
52 };
53 
54 class CC_EXPORT FloatKeyframe : public Keyframe {
55  public:
56   static scoped_ptr<FloatKeyframe> Create(
57       double time,
58       float value,
59       scoped_ptr<TimingFunction> timing_function);
60   virtual ~FloatKeyframe();
61 
62   float Value() const;
63 
64   scoped_ptr<FloatKeyframe> Clone() const;
65 
66  private:
67   FloatKeyframe(double time,
68                 float value,
69                 scoped_ptr<TimingFunction> timing_function);
70 
71   float value_;
72 };
73 
74 class CC_EXPORT TransformKeyframe : public Keyframe {
75  public:
76   static scoped_ptr<TransformKeyframe> Create(
77       double time,
78       const TransformOperations& value,
79       scoped_ptr<TimingFunction> timing_function);
80   virtual ~TransformKeyframe();
81 
82   const TransformOperations& Value() const;
83 
84   scoped_ptr<TransformKeyframe> Clone() const;
85 
86  private:
87   TransformKeyframe(
88       double time,
89       const TransformOperations& value,
90       scoped_ptr<TimingFunction> timing_function);
91 
92   TransformOperations value_;
93 };
94 
95 class CC_EXPORT FilterKeyframe : public Keyframe {
96  public:
97   static scoped_ptr<FilterKeyframe> Create(
98       double time,
99       const FilterOperations& value,
100       scoped_ptr<TimingFunction> timing_function);
101   virtual ~FilterKeyframe();
102 
103   const FilterOperations& Value() const;
104 
105   scoped_ptr<FilterKeyframe> Clone() const;
106 
107  private:
108   FilterKeyframe(
109       double time,
110       const FilterOperations& value,
111       scoped_ptr<TimingFunction> timing_function);
112 
113   FilterOperations value_;
114 };
115 
116 class CC_EXPORT KeyframedColorAnimationCurve : public ColorAnimationCurve {
117  public:
118   // It is required that the keyframes be sorted by time.
119   static scoped_ptr<KeyframedColorAnimationCurve> Create();
120 
121   virtual ~KeyframedColorAnimationCurve();
122 
123   void AddKeyframe(scoped_ptr<ColorKeyframe> keyframe);
124 
125   // AnimationCurve implementation
126   virtual double Duration() const OVERRIDE;
127   virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
128 
129   // BackgrounColorAnimationCurve implementation
130   virtual SkColor GetValue(double t) const OVERRIDE;
131 
132  private:
133   KeyframedColorAnimationCurve();
134 
135   // Always sorted in order of increasing time. No two keyframes have the
136   // same time.
137   ScopedPtrVector<ColorKeyframe> keyframes_;
138 
139   DISALLOW_COPY_AND_ASSIGN(KeyframedColorAnimationCurve);
140 };
141 
142 class CC_EXPORT KeyframedFloatAnimationCurve : public FloatAnimationCurve {
143  public:
144   // It is required that the keyframes be sorted by time.
145   static scoped_ptr<KeyframedFloatAnimationCurve> Create();
146 
147   virtual ~KeyframedFloatAnimationCurve();
148 
149   void AddKeyframe(scoped_ptr<FloatKeyframe> keyframe);
150 
151   // AnimationCurve implementation
152   virtual double Duration() const OVERRIDE;
153   virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
154 
155   // FloatAnimationCurve implementation
156   virtual float GetValue(double t) const OVERRIDE;
157 
158  private:
159   KeyframedFloatAnimationCurve();
160 
161   // Always sorted in order of increasing time. No two keyframes have the
162   // same time.
163   ScopedPtrVector<FloatKeyframe> keyframes_;
164 
165   DISALLOW_COPY_AND_ASSIGN(KeyframedFloatAnimationCurve);
166 };
167 
168 class CC_EXPORT KeyframedTransformAnimationCurve
169     : public TransformAnimationCurve {
170  public:
171   // It is required that the keyframes be sorted by time.
172   static scoped_ptr<KeyframedTransformAnimationCurve> Create();
173 
174   virtual ~KeyframedTransformAnimationCurve();
175 
176   void AddKeyframe(scoped_ptr<TransformKeyframe> keyframe);
177 
178   // AnimationCurve implementation
179   virtual double Duration() const OVERRIDE;
180   virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
181 
182   // TransformAnimationCurve implementation
183   virtual gfx::Transform GetValue(double t) const OVERRIDE;
184   virtual bool AnimatedBoundsForBox(const gfx::BoxF& box,
185                                     gfx::BoxF* bounds) const OVERRIDE;
186 
187  private:
188   KeyframedTransformAnimationCurve();
189 
190   // Always sorted in order of increasing time. No two keyframes have the
191   // same time.
192   ScopedPtrVector<TransformKeyframe> keyframes_;
193 
194   DISALLOW_COPY_AND_ASSIGN(KeyframedTransformAnimationCurve);
195 };
196 
197 class CC_EXPORT KeyframedFilterAnimationCurve
198     : public FilterAnimationCurve {
199  public:
200   // It is required that the keyframes be sorted by time.
201   static scoped_ptr<KeyframedFilterAnimationCurve> Create();
202 
203   virtual ~KeyframedFilterAnimationCurve();
204 
205   void AddKeyframe(scoped_ptr<FilterKeyframe> keyframe);
206 
207   // AnimationCurve implementation
208   virtual double Duration() const OVERRIDE;
209   virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
210 
211   // FilterAnimationCurve implementation
212   virtual FilterOperations GetValue(double t) const OVERRIDE;
213 
214  private:
215   KeyframedFilterAnimationCurve();
216 
217   // Always sorted in order of increasing time. No two keyframes have the
218   // same time.
219   ScopedPtrVector<FilterKeyframe> keyframes_;
220 
221   DISALLOW_COPY_AND_ASSIGN(KeyframedFilterAnimationCurve);
222 };
223 
224 }  // namespace cc
225 
226 #endif  // CC_ANIMATION_KEYFRAMED_ANIMATION_CURVE_H_
227