1 // Copyright (c) 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 #include "ui/gfx/interpolated_transform.h" 6 7 #include <cmath> 8 9 #ifndef M_PI 10 #define M_PI 3.14159265358979323846 11 #endif 12 13 #include "base/logging.h" 14 #include "ui/base/animation/tween.h" 15 16 namespace { 17 18 static const double EPSILON = 1e-6; 19 20 bool IsMultipleOfNinetyDegrees(double degrees) { 21 double remainder = fabs(fmod(degrees, 90.0)); 22 return remainder < EPSILON || 90.0 - remainder < EPSILON; 23 } 24 25 bool IsApproximatelyZero(double value) { 26 return fabs(value) < EPSILON; 27 } 28 29 // Returns false if |degrees| is not a multiple of ninety degrees or if 30 // |rotation| is NULL. It does not affect |rotation| in this case. Otherwise 31 // *rotation is set to be the appropriate sanitized rotation matrix. That is, 32 // the rotation matrix corresponding to |degrees| which has entries that are all 33 // either 0, 1 or -1. 34 bool MassageRotationIfMultipleOfNinetyDegrees(gfx::Transform* rotation, 35 float degrees) { 36 if (!IsMultipleOfNinetyDegrees(degrees) || !rotation) 37 return false; 38 39 gfx::Transform transform; 40 SkMatrix44& m = transform.matrix(); 41 float degrees_by_ninety = degrees / 90.0f; 42 43 int n = static_cast<int>(degrees_by_ninety > 0 44 ? floor(degrees_by_ninety + 0.5f) 45 : ceil(degrees_by_ninety - 0.5f)); 46 47 n %= 4; 48 if (n < 0) 49 n += 4; 50 51 // n should now be in the range [0, 3] 52 if (n == 1) { 53 m.set3x3( 0, 1, 0, 54 -1, 0, 0, 55 0, 0, 1); 56 } else if (n == 2) { 57 m.set3x3(-1, 0, 0, 58 0, -1, 0, 59 0, 0, 1); 60 } else if (n == 3) { 61 m.set3x3( 0, -1, 0, 62 1, 0, 0, 63 0, 0, 1); 64 } 65 66 *rotation = transform; 67 return true; 68 } 69 70 } // namespace 71 72 namespace ui { 73 74 /////////////////////////////////////////////////////////////////////////////// 75 // InterpolatedTransform 76 // 77 78 InterpolatedTransform::InterpolatedTransform() 79 : start_time_(0.0f), 80 end_time_(1.0f), 81 reversed_(false) { 82 } 83 84 InterpolatedTransform::InterpolatedTransform(float start_time, 85 float end_time) 86 : start_time_(start_time), 87 end_time_(end_time), 88 reversed_(false) { 89 } 90 91 InterpolatedTransform::~InterpolatedTransform() {} 92 93 gfx::Transform InterpolatedTransform::Interpolate(float t) const { 94 if (reversed_) 95 t = 1.0f - t; 96 gfx::Transform result = InterpolateButDoNotCompose(t); 97 if (child_.get()) { 98 result.ConcatTransform(child_->Interpolate(t)); 99 } 100 return result; 101 } 102 103 void InterpolatedTransform::SetChild(InterpolatedTransform* child) { 104 child_.reset(child); 105 } 106 107 inline float InterpolatedTransform::ValueBetween(float time, 108 float start_value, 109 float end_value) const { 110 // can't handle NaN 111 DCHECK(time == time && start_time_ == start_time_ && end_time_ == end_time_); 112 if (time != time || start_time_ != start_time_ || end_time_ != end_time_) 113 return start_value; 114 115 // Ok if equal -- we'll get a step function. Note: if end_time_ == 116 // start_time_ == x, then if none of the numbers are NaN, then it 117 // must be true that time < x or time >= x, so we will return early 118 // due to one of the following if statements. 119 DCHECK(end_time_ >= start_time_); 120 121 if (time < start_time_) 122 return start_value; 123 124 if (time >= end_time_) 125 return end_value; 126 127 float t = (time - start_time_) / (end_time_ - start_time_); 128 return static_cast<float>(Tween::ValueBetween(t, start_value, end_value)); 129 } 130 131 /////////////////////////////////////////////////////////////////////////////// 132 // InterpolatedRotation 133 // 134 135 InterpolatedRotation::InterpolatedRotation(float start_degrees, 136 float end_degrees) 137 : InterpolatedTransform(), 138 start_degrees_(start_degrees), 139 end_degrees_(end_degrees) { 140 } 141 142 InterpolatedRotation::InterpolatedRotation(float start_degrees, 143 float end_degrees, 144 float start_time, 145 float end_time) 146 : InterpolatedTransform(start_time, end_time), 147 start_degrees_(start_degrees), 148 end_degrees_(end_degrees) { 149 } 150 151 InterpolatedRotation::~InterpolatedRotation() {} 152 153 gfx::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const { 154 gfx::Transform result; 155 float interpolated_degrees = ValueBetween(t, start_degrees_, end_degrees_); 156 result.Rotate(interpolated_degrees); 157 if (t == 0.0f || t == 1.0f) 158 MassageRotationIfMultipleOfNinetyDegrees(&result, interpolated_degrees); 159 return result; 160 } 161 162 /////////////////////////////////////////////////////////////////////////////// 163 // InterpolatedAxisAngleRotation 164 // 165 166 InterpolatedAxisAngleRotation::InterpolatedAxisAngleRotation( 167 const gfx::Vector3dF& axis, 168 float start_degrees, 169 float end_degrees) 170 : InterpolatedTransform(), 171 axis_(axis), 172 start_degrees_(start_degrees), 173 end_degrees_(end_degrees) { 174 } 175 176 InterpolatedAxisAngleRotation::InterpolatedAxisAngleRotation( 177 const gfx::Vector3dF& axis, 178 float start_degrees, 179 float end_degrees, 180 float start_time, 181 float end_time) 182 : InterpolatedTransform(start_time, end_time), 183 axis_(axis), 184 start_degrees_(start_degrees), 185 end_degrees_(end_degrees) { 186 } 187 188 InterpolatedAxisAngleRotation::~InterpolatedAxisAngleRotation() {} 189 190 gfx::Transform 191 InterpolatedAxisAngleRotation::InterpolateButDoNotCompose(float t) const { 192 gfx::Transform result; 193 result.RotateAbout(axis_, ValueBetween(t, start_degrees_, end_degrees_)); 194 return result; 195 } 196 197 /////////////////////////////////////////////////////////////////////////////// 198 // InterpolatedScale 199 // 200 201 InterpolatedScale::InterpolatedScale(float start_scale, float end_scale) 202 : InterpolatedTransform(), 203 start_scale_(gfx::Point3F(start_scale, start_scale, start_scale)), 204 end_scale_(gfx::Point3F(end_scale, end_scale, end_scale)) { 205 } 206 207 InterpolatedScale::InterpolatedScale(float start_scale, float end_scale, 208 float start_time, float end_time) 209 : InterpolatedTransform(start_time, end_time), 210 start_scale_(gfx::Point3F(start_scale, start_scale, start_scale)), 211 end_scale_(gfx::Point3F(end_scale, end_scale, end_scale)) { 212 } 213 214 InterpolatedScale::InterpolatedScale(const gfx::Point3F& start_scale, 215 const gfx::Point3F& end_scale) 216 : InterpolatedTransform(), 217 start_scale_(start_scale), 218 end_scale_(end_scale) { 219 } 220 221 InterpolatedScale::InterpolatedScale(const gfx::Point3F& start_scale, 222 const gfx::Point3F& end_scale, 223 float start_time, 224 float end_time) 225 : InterpolatedTransform(start_time, end_time), 226 start_scale_(start_scale), 227 end_scale_(end_scale) { 228 } 229 230 InterpolatedScale::~InterpolatedScale() {} 231 232 gfx::Transform InterpolatedScale::InterpolateButDoNotCompose(float t) const { 233 gfx::Transform result; 234 float scale_x = ValueBetween(t, start_scale_.x(), end_scale_.x()); 235 float scale_y = ValueBetween(t, start_scale_.y(), end_scale_.y()); 236 // TODO(vollick) 3d xforms. 237 result.Scale(scale_x, scale_y); 238 return result; 239 } 240 241 /////////////////////////////////////////////////////////////////////////////// 242 // InterpolatedTranslation 243 // 244 245 InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos, 246 const gfx::Point& end_pos) 247 : InterpolatedTransform(), 248 start_pos_(start_pos), 249 end_pos_(end_pos) { 250 } 251 252 InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos, 253 const gfx::Point& end_pos, 254 float start_time, 255 float end_time) 256 : InterpolatedTransform(start_time, end_time), 257 start_pos_(start_pos), 258 end_pos_(end_pos) { 259 } 260 261 InterpolatedTranslation::~InterpolatedTranslation() {} 262 263 gfx::Transform 264 InterpolatedTranslation::InterpolateButDoNotCompose(float t) const { 265 gfx::Transform result; 266 // TODO(vollick) 3d xforms. 267 result.Translate(ValueBetween(t, start_pos_.x(), end_pos_.x()), 268 ValueBetween(t, start_pos_.y(), end_pos_.y())); 269 return result; 270 } 271 272 /////////////////////////////////////////////////////////////////////////////// 273 // InterpolatedConstantTransform 274 // 275 276 InterpolatedConstantTransform::InterpolatedConstantTransform( 277 const gfx::Transform& transform) 278 : InterpolatedTransform(), 279 transform_(transform) { 280 } 281 282 gfx::Transform 283 InterpolatedConstantTransform::InterpolateButDoNotCompose(float t) const { 284 return transform_; 285 } 286 287 InterpolatedConstantTransform::~InterpolatedConstantTransform() {} 288 289 /////////////////////////////////////////////////////////////////////////////// 290 // InterpolatedTransformAboutPivot 291 // 292 293 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot( 294 const gfx::Point& pivot, 295 InterpolatedTransform* transform) 296 : InterpolatedTransform() { 297 Init(pivot, transform); 298 } 299 300 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot( 301 const gfx::Point& pivot, 302 InterpolatedTransform* transform, 303 float start_time, 304 float end_time) 305 : InterpolatedTransform() { 306 Init(pivot, transform); 307 } 308 309 InterpolatedTransformAboutPivot::~InterpolatedTransformAboutPivot() {} 310 311 gfx::Transform 312 InterpolatedTransformAboutPivot::InterpolateButDoNotCompose(float t) const { 313 if (transform_.get()) { 314 return transform_->Interpolate(t); 315 } 316 return gfx::Transform(); 317 } 318 319 void InterpolatedTransformAboutPivot::Init(const gfx::Point& pivot, 320 InterpolatedTransform* xform) { 321 gfx::Transform to_pivot; 322 gfx::Transform from_pivot; 323 to_pivot.Translate(-pivot.x(), -pivot.y()); 324 from_pivot.Translate(pivot.x(), pivot.y()); 325 326 scoped_ptr<InterpolatedTransform> pre_transform( 327 new InterpolatedConstantTransform(to_pivot)); 328 scoped_ptr<InterpolatedTransform> post_transform( 329 new InterpolatedConstantTransform(from_pivot)); 330 331 pre_transform->SetChild(xform); 332 xform->SetChild(post_transform.release()); 333 transform_.reset(pre_transform.release()); 334 } 335 336 InterpolatedMatrixTransform::InterpolatedMatrixTransform( 337 const gfx::Transform& start_transform, 338 const gfx::Transform& end_transform) 339 : InterpolatedTransform() { 340 Init(start_transform, end_transform); 341 } 342 343 InterpolatedMatrixTransform::InterpolatedMatrixTransform( 344 const gfx::Transform& start_transform, 345 const gfx::Transform& end_transform, 346 float start_time, 347 float end_time) 348 : InterpolatedTransform() { 349 Init(start_transform, end_transform); 350 } 351 352 InterpolatedMatrixTransform::~InterpolatedMatrixTransform() {} 353 354 gfx::Transform 355 InterpolatedMatrixTransform::InterpolateButDoNotCompose(float t) const { 356 gfx::DecomposedTransform blended; 357 bool success = gfx::BlendDecomposedTransforms(&blended, 358 end_decomp_, 359 start_decomp_, 360 t); 361 DCHECK(success); 362 return gfx::ComposeTransform(blended); 363 } 364 365 void InterpolatedMatrixTransform::Init(const gfx::Transform& start_transform, 366 const gfx::Transform& end_transform) { 367 bool success = gfx::DecomposeTransform(&start_decomp_, start_transform); 368 DCHECK(success); 369 success = gfx::DecomposeTransform(&end_decomp_, end_transform); 370 DCHECK(success); 371 } 372 373 } // namespace ui 374
