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