1 // Copyright 2013 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 "cc/animation/transform_operations.h" 6 7 #include <algorithm> 8 9 #include "ui/gfx/animation/tween.h" 10 #include "ui/gfx/box_f.h" 11 #include "ui/gfx/transform_util.h" 12 #include "ui/gfx/vector3d_f.h" 13 14 namespace cc { 15 16 TransformOperations::TransformOperations() 17 : decomposed_transform_dirty_(true) { 18 } 19 20 TransformOperations::TransformOperations(const TransformOperations& other) { 21 operations_ = other.operations_; 22 decomposed_transform_dirty_ = other.decomposed_transform_dirty_; 23 if (!decomposed_transform_dirty_) { 24 decomposed_transform_.reset( 25 new gfx::DecomposedTransform(*other.decomposed_transform_.get())); 26 } 27 } 28 29 TransformOperations::~TransformOperations() { 30 } 31 32 gfx::Transform TransformOperations::Apply() const { 33 gfx::Transform to_return; 34 for (size_t i = 0; i < operations_.size(); ++i) 35 to_return.PreconcatTransform(operations_[i].matrix); 36 return to_return; 37 } 38 39 gfx::Transform TransformOperations::Blend(const TransformOperations& from, 40 SkMScalar progress) const { 41 gfx::Transform to_return; 42 BlendInternal(from, progress, &to_return); 43 return to_return; 44 } 45 46 bool TransformOperations::BlendedBoundsForBox(const gfx::BoxF& box, 47 const TransformOperations& from, 48 SkMScalar min_progress, 49 SkMScalar max_progress, 50 gfx::BoxF* bounds) const { 51 *bounds = box; 52 53 bool from_identity = from.IsIdentity(); 54 bool to_identity = IsIdentity(); 55 if (from_identity && to_identity) 56 return true; 57 58 if (!MatchesTypes(from)) 59 return false; 60 61 size_t num_operations = 62 std::max(from_identity ? 0 : from.operations_.size(), 63 to_identity ? 0 : operations_.size()); 64 65 // Because we are squashing all of the matrices together when applying 66 // them to the animation, we must apply them in reverse order when 67 // not squashing them. 68 for (int i = num_operations - 1; i >= 0; --i) { 69 gfx::BoxF bounds_for_operation; 70 const TransformOperation* from_op = 71 from_identity ? NULL : &from.operations_[i]; 72 const TransformOperation* to_op = to_identity ? NULL : &operations_[i]; 73 if (!TransformOperation::BlendedBoundsForBox(*bounds, 74 from_op, 75 to_op, 76 min_progress, 77 max_progress, 78 &bounds_for_operation)) 79 return false; 80 *bounds = bounds_for_operation; 81 } 82 83 return true; 84 } 85 86 bool TransformOperations::AffectsScale() const { 87 for (size_t i = 0; i < operations_.size(); ++i) { 88 if (operations_[i].type == TransformOperation::TransformOperationScale) 89 return true; 90 if (operations_[i].type == TransformOperation::TransformOperationMatrix && 91 !operations_[i].matrix.IsIdentityOrTranslation()) 92 return true; 93 } 94 return false; 95 } 96 97 bool TransformOperations::IsTranslation() const { 98 for (size_t i = 0; i < operations_.size(); ++i) { 99 switch (operations_[i].type) { 100 case TransformOperation::TransformOperationIdentity: 101 case TransformOperation::TransformOperationTranslate: 102 continue; 103 case TransformOperation::TransformOperationMatrix: 104 if (!operations_[i].matrix.IsIdentityOrTranslation()) 105 return false; 106 continue; 107 case TransformOperation::TransformOperationRotate: 108 case TransformOperation::TransformOperationScale: 109 case TransformOperation::TransformOperationSkew: 110 case TransformOperation::TransformOperationPerspective: 111 return false; 112 } 113 } 114 return true; 115 } 116 117 bool TransformOperations::MaximumScale(const TransformOperations& from, 118 SkMScalar min_progress, 119 SkMScalar max_progress, 120 float* max_scale) const { 121 if (!MatchesTypes(from)) 122 return false; 123 124 gfx::Vector3dF from_scale; 125 gfx::Vector3dF to_scale; 126 127 if (!from.ScaleComponent(&from_scale) || !ScaleComponent(&to_scale)) 128 return false; 129 130 gfx::Vector3dF scale_at_min_progress( 131 std::abs(gfx::Tween::FloatValueBetween( 132 min_progress, from_scale.x(), to_scale.x())), 133 std::abs(gfx::Tween::FloatValueBetween( 134 min_progress, from_scale.y(), to_scale.y())), 135 std::abs(gfx::Tween::FloatValueBetween( 136 min_progress, from_scale.z(), to_scale.z()))); 137 gfx::Vector3dF scale_at_max_progress( 138 std::abs(gfx::Tween::FloatValueBetween( 139 max_progress, from_scale.x(), to_scale.x())), 140 std::abs(gfx::Tween::FloatValueBetween( 141 max_progress, from_scale.y(), to_scale.y())), 142 std::abs(gfx::Tween::FloatValueBetween( 143 max_progress, from_scale.z(), to_scale.z()))); 144 145 gfx::Vector3dF max_scale_3d = scale_at_min_progress; 146 max_scale_3d.SetToMax(scale_at_max_progress); 147 *max_scale = 148 std::max(max_scale_3d.x(), std::max(max_scale_3d.y(), max_scale_3d.z())); 149 return true; 150 } 151 152 bool TransformOperations::ScaleComponent(gfx::Vector3dF* scale) const { 153 *scale = gfx::Vector3dF(1.f, 1.f, 1.f); 154 bool has_scale_component = false; 155 for (size_t i = 0; i < operations_.size(); ++i) { 156 switch (operations_[i].type) { 157 case TransformOperation::TransformOperationIdentity: 158 case TransformOperation::TransformOperationTranslate: 159 continue; 160 case TransformOperation::TransformOperationMatrix: 161 if (!operations_[i].matrix.IsIdentityOrTranslation()) 162 return false; 163 continue; 164 case TransformOperation::TransformOperationRotate: 165 case TransformOperation::TransformOperationSkew: 166 case TransformOperation::TransformOperationPerspective: 167 return false; 168 case TransformOperation::TransformOperationScale: 169 if (has_scale_component) 170 return false; 171 has_scale_component = true; 172 scale->Scale(operations_[i].scale.x, 173 operations_[i].scale.y, 174 operations_[i].scale.z); 175 } 176 } 177 return true; 178 } 179 180 bool TransformOperations::MatchesTypes(const TransformOperations& other) const { 181 if (IsIdentity() || other.IsIdentity()) 182 return true; 183 184 if (operations_.size() != other.operations_.size()) 185 return false; 186 187 for (size_t i = 0; i < operations_.size(); ++i) { 188 if (operations_[i].type != other.operations_[i].type 189 && !operations_[i].IsIdentity() 190 && !other.operations_[i].IsIdentity()) 191 return false; 192 } 193 194 return true; 195 } 196 197 bool TransformOperations::CanBlendWith( 198 const TransformOperations& other) const { 199 gfx::Transform dummy; 200 return BlendInternal(other, 0.5, &dummy); 201 } 202 203 void TransformOperations::AppendTranslate(SkMScalar x, 204 SkMScalar y, 205 SkMScalar z) { 206 TransformOperation to_add; 207 to_add.matrix.Translate3d(x, y, z); 208 to_add.type = TransformOperation::TransformOperationTranslate; 209 to_add.translate.x = x; 210 to_add.translate.y = y; 211 to_add.translate.z = z; 212 operations_.push_back(to_add); 213 decomposed_transform_dirty_ = true; 214 } 215 216 void TransformOperations::AppendRotate(SkMScalar x, 217 SkMScalar y, 218 SkMScalar z, 219 SkMScalar degrees) { 220 TransformOperation to_add; 221 to_add.matrix.RotateAbout(gfx::Vector3dF(x, y, z), degrees); 222 to_add.type = TransformOperation::TransformOperationRotate; 223 to_add.rotate.axis.x = x; 224 to_add.rotate.axis.y = y; 225 to_add.rotate.axis.z = z; 226 to_add.rotate.angle = degrees; 227 operations_.push_back(to_add); 228 decomposed_transform_dirty_ = true; 229 } 230 231 void TransformOperations::AppendScale(SkMScalar x, SkMScalar y, SkMScalar z) { 232 TransformOperation to_add; 233 to_add.matrix.Scale3d(x, y, z); 234 to_add.type = TransformOperation::TransformOperationScale; 235 to_add.scale.x = x; 236 to_add.scale.y = y; 237 to_add.scale.z = z; 238 operations_.push_back(to_add); 239 decomposed_transform_dirty_ = true; 240 } 241 242 void TransformOperations::AppendSkew(SkMScalar x, SkMScalar y) { 243 TransformOperation to_add; 244 to_add.matrix.SkewX(x); 245 to_add.matrix.SkewY(y); 246 to_add.type = TransformOperation::TransformOperationSkew; 247 to_add.skew.x = x; 248 to_add.skew.y = y; 249 operations_.push_back(to_add); 250 decomposed_transform_dirty_ = true; 251 } 252 253 void TransformOperations::AppendPerspective(SkMScalar depth) { 254 TransformOperation to_add; 255 to_add.matrix.ApplyPerspectiveDepth(depth); 256 to_add.type = TransformOperation::TransformOperationPerspective; 257 to_add.perspective_depth = depth; 258 operations_.push_back(to_add); 259 decomposed_transform_dirty_ = true; 260 } 261 262 void TransformOperations::AppendMatrix(const gfx::Transform& matrix) { 263 TransformOperation to_add; 264 to_add.matrix = matrix; 265 to_add.type = TransformOperation::TransformOperationMatrix; 266 operations_.push_back(to_add); 267 decomposed_transform_dirty_ = true; 268 } 269 270 void TransformOperations::AppendIdentity() { 271 operations_.push_back(TransformOperation()); 272 } 273 274 bool TransformOperations::IsIdentity() const { 275 for (size_t i = 0; i < operations_.size(); ++i) { 276 if (!operations_[i].IsIdentity()) 277 return false; 278 } 279 return true; 280 } 281 282 bool TransformOperations::BlendInternal(const TransformOperations& from, 283 SkMScalar progress, 284 gfx::Transform* result) const { 285 bool from_identity = from.IsIdentity(); 286 bool to_identity = IsIdentity(); 287 if (from_identity && to_identity) 288 return true; 289 290 if (MatchesTypes(from)) { 291 size_t num_operations = 292 std::max(from_identity ? 0 : from.operations_.size(), 293 to_identity ? 0 : operations_.size()); 294 for (size_t i = 0; i < num_operations; ++i) { 295 gfx::Transform blended; 296 if (!TransformOperation::BlendTransformOperations( 297 from_identity ? 0 : &from.operations_[i], 298 to_identity ? 0 : &operations_[i], 299 progress, 300 &blended)) 301 return false; 302 result->PreconcatTransform(blended); 303 } 304 return true; 305 } 306 307 if (!ComputeDecomposedTransform() || !from.ComputeDecomposedTransform()) 308 return false; 309 310 gfx::DecomposedTransform to_return; 311 if (!gfx::BlendDecomposedTransforms(&to_return, 312 *decomposed_transform_.get(), 313 *from.decomposed_transform_.get(), 314 progress)) 315 return false; 316 317 *result = ComposeTransform(to_return); 318 return true; 319 } 320 321 bool TransformOperations::ComputeDecomposedTransform() const { 322 if (decomposed_transform_dirty_) { 323 if (!decomposed_transform_) 324 decomposed_transform_.reset(new gfx::DecomposedTransform()); 325 gfx::Transform transform = Apply(); 326 if (!gfx::DecomposeTransform(decomposed_transform_.get(), transform)) 327 return false; 328 decomposed_transform_dirty_ = false; 329 } 330 return true; 331 } 332 333 } // namespace cc 334
