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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
// Copyright (c) 2011 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 UI_GFX_INTERPOLATED_TRANSFORM_H_
#define UI_GFX_INTERPOLATED_TRANSFORM_H_
#pragma once
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "ui/gfx/point.h"
#include "ui/gfx/transform.h"
namespace ui {
///////////////////////////////////////////////////////////////////////////////
// class InterpolatedTransform
//
// Abstract base class for transforms that animate over time. These
// interpolated transforms can be combined to allow for more sophisticated
// animations. For example, you might combine a rotation of 90 degrees between
// times 0 and 1, with a scale from 1 to 0.3 between times 0 and 0.25 and a
// scale from 0.3 to 1 from between times 0.75 and 1.
//
///////////////////////////////////////////////////////////////////////////////
class InterpolatedTransform {
public:
InterpolatedTransform();
// The interpolated transform varies only when t in (start_time, end_time).
// If t <= start_time, Interpolate(t) will return the initial transform, and
// if t >= end_time, Interpolate(t) will return the final transform.
InterpolatedTransform(float start_time, float end_time);
virtual ~InterpolatedTransform();
// Returns the interpolated transform at time t. Note: not virtual.
ui::Transform Interpolate(float t) const;
// The Intepolate ultimately returns the product of our transform at time t
// and our child's transform at time t (if we have one).
//
// This function takes ownership of the passed InterpolatedTransform.
void SetChild(InterpolatedTransform* child);
protected:
// Calculates the interpolated transform without considering our child.
virtual ui::Transform InterpolateButDoNotCompose(float t) const = 0;
// If time in (start_time_, end_time_], this function linearly interpolates
// between start_value and end_value. More precisely it returns
// (1 - t) * start_value + t * end_value where
// t = (start_time_ - time) / (end_time_ - start_time_).
// If time < start_time_ it returns start_value, and if time >= end_time_
// it returns end_value.
float ValueBetween(float time, float start_value, float end_value) const;
private:
const float start_time_;
const float end_time_;
// The child transform. If you consider an interpolated transform as a
// function of t. If, without a child, we are f(t), and our child is
// g(t), then with a child we become f'(t) = f(t) * g(t). Using a child
// transform, we can chain collections of transforms together.
scoped_ptr<InterpolatedTransform> child_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedTransform);
};
///////////////////////////////////////////////////////////////////////////////
// class InterpolatedRotation
//
// Represents an animated rotation.
//
///////////////////////////////////////////////////////////////////////////////
class InterpolatedRotation : public InterpolatedTransform {
public:
InterpolatedRotation(float start_degrees, float end_degrees);
InterpolatedRotation(float start_degrees,
float end_degrees,
float start_time,
float end_time);
virtual ~InterpolatedRotation();
protected:
virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
private:
const float start_degrees_;
const float end_degrees_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedRotation);
};
///////////////////////////////////////////////////////////////////////////////
// class InterpolatedScale
//
// Represents an animated scale.
//
///////////////////////////////////////////////////////////////////////////////
class InterpolatedScale : public InterpolatedTransform {
public:
InterpolatedScale(float start_scale, float end_scale);
InterpolatedScale(float start_scale,
float end_scale,
float start_time,
float end_time);
virtual ~InterpolatedScale();
protected:
virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
private:
const float start_scale_;
const float end_scale_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedScale);
};
class InterpolatedTranslation : public InterpolatedTransform {
public:
InterpolatedTranslation(const gfx::Point& start_pos,
const gfx::Point& end_pos);
InterpolatedTranslation(const gfx::Point& start_pos,
const gfx::Point& end_pos,
float start_time,
float end_time);
virtual ~InterpolatedTranslation();
protected:
virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
private:
const gfx::Point start_pos_;
const gfx::Point end_pos_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedTranslation);
};
///////////////////////////////////////////////////////////////////////////////
// class InterpolatedConstantTransform
//
// Represents a transform that is constant over time. This is only useful when
// composed with other interpolated transforms.
//
// See InterpolatedTransformAboutPivot for an example of its usage.
//
///////////////////////////////////////////////////////////////////////////////
class InterpolatedConstantTransform : public InterpolatedTransform {
public:
InterpolatedConstantTransform(const ui::Transform& transform);
virtual ~InterpolatedConstantTransform();
protected:
virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
private:
const ui::Transform transform_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedConstantTransform);
};
///////////////////////////////////////////////////////////////////////////////
// class InterpolatedTransformAboutPivot
//
// Represents an animated transform with a transformed origin. Essentially,
// at each time, t, the interpolated transform is created by composing
// P * T * P^-1 where P is a constant transform to the new origin.
//
///////////////////////////////////////////////////////////////////////////////
class InterpolatedTransformAboutPivot : public InterpolatedTransform {
public:
// Takes ownership of the passed transform.
InterpolatedTransformAboutPivot(const gfx::Point& pivot,
InterpolatedTransform* transform);
// Takes ownership of the passed transform.
InterpolatedTransformAboutPivot(const gfx::Point& pivot,
InterpolatedTransform* transform,
float start_time,
float end_time);
virtual ~InterpolatedTransformAboutPivot();
protected:
virtual ui::Transform InterpolateButDoNotCompose(float t) const OVERRIDE;
private:
void Init(const gfx::Point& pivot, InterpolatedTransform* transform);
scoped_ptr<InterpolatedTransform> transform_;
DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformAboutPivot);
};
} // namespace ui
#endif // UI_GFX_INTERPOLATED_TRANSFORM_H_
|
