third_party/WebKit/Source/platform/transforms/TransformOperations.cpp

   1 /*
   2  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
   3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #include "config.h"
  23 #include "platform/transforms/TransformOperations.h"
  24
  25 #include "platform/animation/AnimationUtilities.h"
  26 #include "platform/geometry/FloatBox.h"
  27 #include "platform/transforms/IdentityTransformOperation.h"
  28 #include "platform/transforms/InterpolatedTransformOperation.h"
  29 #include "platform/transforms/RotateTransformOperation.h"
  30 #include <algorithm>
  31
  32 namespace blink {
  33
  34 TransformOperations::TransformOperations(bool makeIdentity)
  35 {
  36     if (makeIdentity)
  37         m_operations.append(IdentityTransformOperation::create());
  38 }
  39
  40 bool TransformOperations::operator==(const TransformOperations& o) const
  41 {
  42     if (m_operations.size() != o.m_operations.size())
  43         return false;
  44
  45     unsigned s = m_operations.size();
  46     for (unsigned i = 0; i < s; i++) {
  47         if (*m_operations[i] != *o.m_operations[i])
  48             return false;
  49     }
  50
  51     return true;
  52 }
  53
  54 bool TransformOperations::operationsMatch(const TransformOperations& other) const
  55 {
  56     size_t numOperations = operations().size();
  57     // If the sizes of the function lists don't match, the lists don't match
  58     if (numOperations != other.operations().size())
  59         return false;
  60
  61     // If the types of each function are not the same, the lists don't match
  62     for (size_t i = 0; i < numOperations; ++i) {
  63         if (!operations()[i]->isSameType(*other.operations()[i]))
  64             return false;
  65     }
  66     return true;
  67 }
  68
  69 TransformOperations TransformOperations::blendByMatchingOperations(const TransformOperations& from, const double& progress) const
  70 {
  71     TransformOperations result;
  72
  73     unsigned fromSize = from.operations().size();
  74     unsigned toSize = operations().size();
  75     unsigned size = std::max(fromSize, toSize);
  76     for (unsigned i = 0; i < size; i++) {
  77         RefPtr<TransformOperation> fromOperation = (i < fromSize) ? from.operations()[i].get() : 0;
  78         RefPtr<TransformOperation> toOperation = (i < toSize) ? operations()[i].get() : 0;
  79         RefPtr<TransformOperation> blendedOperation = toOperation ? toOperation->blend(fromOperation.get(), progress) : (fromOperation ? fromOperation->blend(0, progress, true) : nullptr);
  80         if (blendedOperation)
  81             result.operations().append(blendedOperation);
  82         else {
  83             RefPtr<TransformOperation> identityOperation = IdentityTransformOperation::create();
  84             if (progress > 0.5)
  85                 result.operations().append(toOperation ? toOperation : identityOperation);
  86             else
  87                 result.operations().append(fromOperation ? fromOperation : identityOperation);
  88         }
  89     }
  90
  91     return result;
  92 }
  93
  94 TransformOperations TransformOperations::blendByUsingMatrixInterpolation(const TransformOperations& from, double progress) const
  95 {
  96     TransformOperations result;
  97     result.operations().append(InterpolatedTransformOperation::create(from, *this, progress));
  98     return result;
  99 }
 100
 101 TransformOperations TransformOperations::blend(const TransformOperations& from, double progress) const
 102 {
 103     if (from == *this || (!from.size() && !size()))
 104         return *this;
 105
 106     // If either list is empty, use blendByMatchingOperations which has special logic for this case.
 107     if (!from.size() || !size() || from.operationsMatch(*this))
 108         return blendByMatchingOperations(from, progress);
 109
 110     return blendByUsingMatrixInterpolation(from, progress);
 111 }
 112
 113 static void findCandidatesInPlane(double px, double py, double nz, double* candidates, int* numCandidates)
 114 {
 115     // The angle that this point is rotated with respect to the plane nz
 116     double phi = atan2(px, py);
 117
 118     *numCandidates = 4;
 119     candidates[0] = phi; // The element at 0deg (maximum x)
 120
 121     for (int i = 1; i < *numCandidates; ++i)
 122         candidates[i] = candidates[i - 1] + M_PI_2; // every 90 deg
 123     if (nz < 0.f) {
 124         for (int i = 0; i < *numCandidates; ++i)
 125             candidates[i] *= -1;
 126     }
 127 }
 128
 129 // This method returns the bounding box that contains the starting point,
 130 // the ending point, and any of the extrema (in each dimension) found across
 131 // the circle described by the arc. These are then filtered to points that
 132 // actually reside on the arc.
 133 static void boundingBoxForArc(const FloatPoint3D& point, const RotateTransformOperation& fromTransform, const RotateTransformOperation& toTransform, double minProgress, double maxProgress, FloatBox& box)
 134 {
 135     double candidates[6];
 136     int numCandidates = 0;
 137
 138     FloatPoint3D axis(fromTransform.axis());
 139     double fromDegrees = fromTransform.angle();
 140     double toDegrees = toTransform.angle();
 141
 142     if (axis.dot(toTransform.axis()) < 0)
 143         toDegrees *= -1;
 144
 145     fromDegrees  = blend(fromDegrees, toTransform.angle(), minProgress);
 146     toDegrees = blend(toDegrees, fromTransform.angle(), 1.0 - maxProgress);
 147     if (fromDegrees > toDegrees)
 148         std::swap(fromDegrees, toDegrees);
 149
 150     TransformationMatrix fromMatrix;
 151     TransformationMatrix toMatrix;
 152     fromMatrix.rotate3d(fromTransform.x(), fromTransform.y(), fromTransform.z(), fromDegrees);
 153     toMatrix.rotate3d(fromTransform.x(), fromTransform.y(), fromTransform.z(), toDegrees);
 154
 155     FloatPoint3D fromPoint = fromMatrix.mapPoint(point);
 156     FloatPoint3D toPoint = toMatrix.mapPoint(point);
 157
 158     if (box.isEmpty())
 159         box.setOrigin(fromPoint);
 160     else
 161         box.expandTo(fromPoint);
 162
 163     box.expandTo(toPoint);
 164
 165     switch (fromTransform.type()) {
 166     case TransformOperation::RotateX:
 167         findCandidatesInPlane(point.y(), point.z(), fromTransform.x(), candidates, &numCandidates);
 168         break;
 169     case TransformOperation::RotateY:
 170         findCandidatesInPlane(point.z(), point.x(), fromTransform.y(), candidates, &numCandidates);
 171         break;
 172     case TransformOperation::RotateZ:
 173         findCandidatesInPlane(point.x(), point.y(), fromTransform.z(), candidates, &numCandidates);
 174         break;
 175     default:
 176         {
 177             FloatPoint3D normal = axis;
 178             if (normal.isZero())
 179                 return;
 180             normal.normalize();
 181             FloatPoint3D origin;
 182             FloatPoint3D toPoint = point - origin;
 183             FloatPoint3D center = origin + normal * toPoint.dot(normal);
 184             FloatPoint3D v1 = point - center;
 185             if (v1.isZero())
 186                 return;
 187
 188             v1.normalize();
 189             FloatPoint3D v2 = normal.cross(v1);
 190             // v1 is the basis vector in the direction of the point.
 191             // i.e. with a rotation of 0, v1 is our +x vector.
 192             // v2 is a perpenticular basis vector of our plane (+y).
 193
 194             // Take the parametric equation of a circle.
 195             // (x = r*cos(t); y = r*sin(t);
 196             // We can treat that as a circle on the plane v1xv2
 197             // From that we get the parametric equations for a circle on the
 198             // plane in 3d space of
 199             // x(t) = r*cos(t)*v1.x + r*sin(t)*v2.x + cx
 200             // y(t) = r*cos(t)*v1.y + r*sin(t)*v2.y + cy
 201             // z(t) = r*cos(t)*v1.z + r*sin(t)*v2.z + cz
 202             // taking the derivative of (x, y, z) and solving for 0 gives us our
 203             // maximum/minimum x, y, z values
 204             // x'(t) = r*cos(t)*v2.x - r*sin(t)*v1.x = 0
 205             // tan(t) = v2.x/v1.x
 206             // t = atan2(v2.x, v1.x) + n*M_PI;
 207
 208             candidates[0] = atan2(v2.x(), v1.x());
 209             candidates[1] = candidates[0] + M_PI;
 210             candidates[2] = atan2(v2.y(), v1.y());
 211             candidates[3] = candidates[2] + M_PI;
 212             candidates[4] = atan2(v2.z(), v1.z());
 213             candidates[5] = candidates[4] + M_PI;
 214             numCandidates = 6;
 215         }
 216         break;
 217     }
 218
 219     double minRadians = deg2rad(fromDegrees);
 220     double maxRadians = deg2rad(toDegrees);
 221     // Once we have the candidates, we now filter them down to ones that
 222     // actually live on the arc, rather than the entire circle.
 223     for (int i = 0; i < numCandidates; ++i) {
 224         double radians = candidates[i];
 225
 226         while (radians < minRadians)
 227             radians += 2.0 * M_PI;
 228         while (radians > maxRadians)
 229             radians -= 2.0 * M_PI;
 230         if (radians < minRadians)
 231             continue;
 232
 233         TransformationMatrix rotation;
 234         rotation.rotate3d(axis.x(), axis.y(), axis.z(), rad2deg(radians));
 235         box.expandTo(rotation.mapPoint(point));
 236     }
 237 }
 238
 239 bool TransformOperations::blendedBoundsForBox(const FloatBox& box, const TransformOperations& from, const double& minProgress, const double& maxProgress, FloatBox* bounds) const
 240 {
 241
 242     int fromSize = from.operations().size();
 243     int toSize = operations().size();
 244     int size = std::max(fromSize, toSize);
 245
 246     *bounds = box;
 247     for (int i = size - 1; i >= 0; i--) {
 248         RefPtr<TransformOperation> fromOperation = (i < fromSize) ? from.operations()[i] : nullptr;
 249         RefPtr<TransformOperation> toOperation = (i < toSize) ? operations()[i] : nullptr;
 250         if (fromOperation && fromOperation->type() == TransformOperation::None)
 251             fromOperation = nullptr;
 252
 253         if (toOperation && toOperation->type() == TransformOperation::None)
 254             toOperation = nullptr;
 255
 256         TransformOperation::OperationType interpolationType = toOperation ? toOperation->type() :
 257             fromOperation ? fromOperation->type() :
 258             TransformOperation::None;
 259         if (fromOperation && toOperation && !fromOperation->canBlendWith(*toOperation.get()))
 260             return false;
 261
 262         switch (interpolationType) {
 263         case TransformOperation::Identity:
 264             bounds->expandTo(box);
 265             continue;
 266         case TransformOperation::Translate:
 267         case TransformOperation::TranslateX:
 268         case TransformOperation::TranslateY:
 269         case TransformOperation::TranslateZ:
 270         case TransformOperation::Translate3D:
 271         case TransformOperation::Scale:
 272         case TransformOperation::ScaleX:
 273         case TransformOperation::ScaleY:
 274         case TransformOperation::ScaleZ:
 275         case TransformOperation::Scale3D:
 276         case TransformOperation::Skew:
 277         case TransformOperation::SkewX:
 278         case TransformOperation::SkewY:
 279         case TransformOperation::Perspective:
 280             {
 281                 RefPtr<TransformOperation> fromTransform;
 282                 RefPtr<TransformOperation> toTransform;
 283                 if (!toOperation) {
 284                     fromTransform = fromOperation->blend(toOperation.get(), 1-minProgress, false);
 285                     toTransform = fromOperation->blend(toOperation.get(), 1-maxProgress, false);
 286                 } else {
 287                     fromTransform = toOperation->blend(fromOperation.get(), minProgress, false);
 288                     toTransform = toOperation->blend(fromOperation.get(), maxProgress, false);
 289                 }
 290                 if (!fromTransform || !toTransform)
 291                     continue;
 292                 TransformationMatrix fromMatrix;
 293                 TransformationMatrix toMatrix;
 294                 fromTransform->apply(fromMatrix, FloatSize());
 295                 toTransform->apply(toMatrix, FloatSize());
 296                 FloatBox fromBox = *bounds;
 297                 FloatBox toBox = *bounds;
 298                 fromMatrix.transformBox(fromBox);
 299                 toMatrix.transformBox(toBox);
 300                 *bounds = fromBox;
 301                 bounds->expandTo(toBox);
 302                 continue;
 303             }
 304         case TransformOperation::Rotate: // This is also RotateZ
 305         case TransformOperation::Rotate3D:
 306         case TransformOperation::RotateX:
 307         case TransformOperation::RotateY:
 308             {
 309                 RefPtr<RotateTransformOperation> identityRotation;
 310                 const RotateTransformOperation* fromRotation = nullptr;
 311                 const RotateTransformOperation* toRotation = nullptr;
 312                 if (fromOperation) {
 313                     fromRotation = static_cast<const RotateTransformOperation*>(fromOperation.get());
 314                     if (fromRotation->axis().isZero())
 315                         fromRotation = nullptr;
 316                 }
 317
 318                 if (toOperation) {
 319                     toRotation = static_cast<const RotateTransformOperation*>(toOperation.get());
 320                     if (toRotation->axis().isZero())
 321                         toRotation = nullptr;
 322                 }
 323
 324                 double fromAngle;
 325                 double toAngle;
 326                 FloatPoint3D axis;
 327                 if (!RotateTransformOperation::shareSameAxis(fromRotation, toRotation, &axis, &fromAngle, &toAngle)) {
 328                     return(false);
 329                 }
 330
 331                 if (!fromRotation) {
 332                     identityRotation = RotateTransformOperation::create(axis.x(), axis.y(), axis.z(), 0, fromOperation ? fromOperation->type() : toOperation->type());
 333                     fromRotation = identityRotation.get();
 334                 }
 335
 336                 if (!toRotation) {
 337                     if (!identityRotation)
 338                         identityRotation = RotateTransformOperation::create(axis.x(), axis.y(), axis.z(), 0, fromOperation ? fromOperation->type() : toOperation->type());
 339                     toRotation = identityRotation.get();
 340                 }
 341
 342                 FloatBox fromBox = *bounds;
 343                 bool first = true;
 344                 for (size_t i = 0; i < 2; ++i) {
 345                     for (size_t j = 0; j < 2; ++j) {
 346                         for (size_t k = 0; k < 2; ++k) {
 347                             FloatBox boundsForArc;
 348                             FloatPoint3D corner(fromBox.x(), fromBox.y(), fromBox.z());
 349                             corner += FloatPoint3D(i * fromBox.width(), j * fromBox.height(), k * fromBox.depth());
 350                             boundingBoxForArc(corner, *fromRotation, *toRotation, minProgress, maxProgress, boundsForArc);
 351                             if (first) {
 352                                 *bounds = boundsForArc;
 353                                 first = false;
 354                             } else {
 355                                 bounds->expandTo(boundsForArc);
 356                             }
 357                         }
 358                     }
 359                 }
 360             }
 361             continue;
 362         case TransformOperation::None:
 363             continue;
 364         case TransformOperation::Matrix:
 365         case TransformOperation::Matrix3D:
 366         case TransformOperation::Interpolated:
 367             return(false);
 368         }
 369     }
 370
 371     return true;
 372 }
 373
 374 TransformOperations TransformOperations::add(const TransformOperations& addend) const
 375 {
 376     TransformOperations result;
 377     result.m_operations = operations();
 378     result.m_operations.appendVector(addend.operations());
 379     return result;
 380 }
 381
 382 TransformOperations TransformOperations::zoom(double factor) const
 383 {
 384     TransformOperations result;
 385     for (auto& transformOperation : m_operations)
 386         result.m_operations.append(transformOperation->zoom(factor));
 387     return result;
 388 }
 389
 390 } // namespace blink