Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

cc/math_util.cc

 // Copyright 2012 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.
 
 #include "cc/math_util.h"
 
 #include <cmath>
 #include <limits>
 
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
+#include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_f.h"
-#include <public/WebTransformationMatrix.h>
 
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;
 
 namespace cc {
 
 const double MathUtil::PI_DOUBLE = 3.14159265358979323846;
 const float MathUtil::PI_FLOAT = 3.14159265358979323846f;
 const double MathUtil::EPSILON = 1e-9;
 
-static HomogeneousCoordinate projectHomogeneousPoint(const WebTransformationMatrix& transform, const gfx::PointF& p)
+static HomogeneousCoordinate projectHomogeneousPoint(const Transform& transform, const gfx::PointF& p)
 {
     // In this case, the layer we are trying to project onto is perpendicular to ray
     // (point p and z-axis direction) that we are trying to project. This happens when the
     // layer is rotated so that it is infinitesimally thin, or when it is co-planar with
     // the camera origin -- i.e. when the layer is invisible anyway.
-    if (!transform.m33())
+    if (!transform.matrix().getDouble(2, 2))
         return HomogeneousCoordinate(0, 0, 0, 1);
 
     double x = p.x();
     double y = p.y();
-    double z = -(transform.m13() * x + transform.m23() * y + transform.m43()) / transform.m33();
+    double z = -(transform.matrix().getDouble(2, 0) * x + transform.matrix().getDouble(2, 1) * y + transform.matrix().getDouble(2, 3)) / transform.matrix().getDouble(2, 2);
     // implicit definition of w = 1;
 
-    double outX = x * transform.m11() + y * transform.m21() + z * transform.m31() + transform.m41();
-    double outY = x * transform.m12() + y * transform.m22() + z * transform.m32() + transform.m42();
-    double outZ = x * transform.m13() + y * transform.m23() + z * transform.m33() + transform.m43();
-    double outW = x * transform.m14() + y * transform.m24() + z * transform.m34() + transform.m44();
+    double outX = x * transform.matrix().getDouble(0, 0) + y * transform.matrix().getDouble(0, 1) + z * transform.matrix().getDouble(0, 2) + transform.matrix().getDouble(0, 3);
+    double outY = x * transform.matrix().getDouble(1, 0) + y * transform.matrix().getDouble(1, 1) + z * transform.matrix().getDouble(1, 2) + transform.matrix().getDouble(1, 3);
+    double outZ = x * transform.matrix().getDouble(2, 0) + y * transform.matrix().getDouble(2, 1) + z * transform.matrix().getDouble(2, 2) + transform.matrix().getDouble(2, 3);
+    double outW = x * transform.matrix().getDouble(3, 0) + y * transform.matrix().getDouble(3, 1) + z * transform.matrix().getDouble(3, 2) + transform.matrix().getDouble(3, 3);
 
     return HomogeneousCoordinate(outX, outY, outZ, outW);
 }
 
-static HomogeneousCoordinate mapHomogeneousPoint(const WebTransformationMatrix& transform, const gfx::Point3F& p)
+static HomogeneousCoordinate mapHomogeneousPoint(const Transform& transform, const gfx::Point3F& p)
 {
     double x = p.x();
     double y = p.y();
     double z = p.z();
     // implicit definition of w = 1;
 
-    double outX = x * transform.m11() + y * transform.m21() + z * transform.m31() + transform.m41();
-    double outY = x * transform.m12() + y * transform.m22() + z * transform.m32() + transform.m42();
-    double outZ = x * transform.m13() + y * transform.m23() + z * transform.m33() + transform.m43();
-    double outW = x * transform.m14() + y * transform.m24() + z * transform.m34() + transform.m44();
+    double outX = x * transform.matrix().getDouble(0, 0) + y * transform.matrix().getDouble(0, 1) + z * transform.matrix().getDouble(0, 2) + transform.matrix().getDouble(0, 3);
+    double outY = x * transform.matrix().getDouble(1, 0) + y * transform.matrix().getDouble(1, 1) + z * transform.matrix().getDouble(1, 2) + transform.matrix().getDouble(1, 3);
+    double outZ = x * transform.matrix().getDouble(2, 0) + y * transform.matrix().getDouble(2, 1) + z * transform.matrix().getDouble(2, 2) + transform.matrix().getDouble(2, 3);
+    double outW = x * transform.matrix().getDouble(3, 0) + y * transform.matrix().getDouble(3, 1) + z * transform.matrix().getDouble(3, 2) + transform.matrix().getDouble(3, 3);
 
     return HomogeneousCoordinate(outX, outY, outZ, outW);
 }
 
 static HomogeneousCoordinate computeClippedPointForEdge(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2)
 {
     // Points h1 and h2 form a line in 4d, and any point on that line can be represented
     // as an interpolation between h1 and h2:
     //    p = (1-t) h1 + (t) h2
     //
@@ skipping 27 matching lines @@
     ymin = std::min(p.y(), ymin);
     ymax = std::max(p.y(), ymax);
 }
 
 static inline void addVertexToClippedQuad(const gfx::PointF& newVertex, gfx::PointF clippedQuad[8], int& numVerticesInClippedQuad)
 {
     clippedQuad[numVerticesInClippedQuad] = newVertex;
     numVerticesInClippedQuad++;
 }
 
-gfx::Rect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const gfx::Rect& srcRect)
+gfx::Rect MathUtil::mapClippedRect(const Transform& transform, const gfx::Rect& srcRect)
 {
     return gfx::ToEnclosingRect(mapClippedRect(transform, gfx::RectF(srcRect)));
 }
 
-gfx::RectF MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const gfx::RectF& srcRect)
+gfx::RectF MathUtil::mapClippedRect(const Transform& transform, const gfx::RectF& srcRect)
 {
-    if (transform.isIdentityOrTranslation())
-        return srcRect + gfx::Vector2dF(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
+    if (MathUtil::isIdentityOrTranslation(transform))
+        return srcRect + gfx::Vector2dF(static_cast<float>(transform.matrix().getDouble(0, 3)), static_cast<float>(transform.matrix().getDouble(1, 3)));
 
     // Apply the transform, but retain the result in homogeneous coordinates.
     gfx::QuadF q = gfx::QuadF(srcRect);
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, gfx::Point3F(q.p1()));
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, gfx::Point3F(q.p2()));
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, gfx::Point3F(q.p3()));
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, gfx::Point3F(q.p4()));
 
     return computeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
-gfx::RectF MathUtil::projectClippedRect(const WebTransformationMatrix& transform, const gfx::RectF& srcRect)
+gfx::RectF MathUtil::projectClippedRect(const Transform& transform, const gfx::RectF& srcRect)
 {
-    if (transform.isIdentityOrTranslation())
-        return srcRect + gfx::Vector2dF(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
+    if (MathUtil::isIdentityOrTranslation(transform))
+        return srcRect + gfx::Vector2dF(static_cast<float>(transform.matrix().getDouble(0, 3)), static_cast<float>(transform.matrix().getDouble(1, 3)));
 
     // Perform the projection, but retain the result in homogeneous coordinates.
     gfx::QuadF q = gfx::QuadF(srcRect);
     HomogeneousCoordinate h1 = projectHomogeneousPoint(transform, q.p1());
     HomogeneousCoordinate h2 = projectHomogeneousPoint(transform, q.p2());
     HomogeneousCoordinate h3 = projectHomogeneousPoint(transform, q.p3());
     HomogeneousCoordinate h4 = projectHomogeneousPoint(transform, q.p4());
 
     return computeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
-void MathUtil::mapClippedQuad(const WebTransformationMatrix& transform, const gfx::QuadF& srcQuad, gfx::PointF clippedQuad[8], int& numVerticesInClippedQuad)
+void MathUtil::mapClippedQuad(const Transform& transform, const gfx::QuadF& srcQuad, gfx::PointF clippedQuad[8], int& numVerticesInClippedQuad)
 {
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, gfx::Point3F(srcQuad.p1()));
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, gfx::Point3F(srcQuad.p2()));
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, gfx::Point3F(srcQuad.p3()));
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, gfx::Point3F(srcQuad.p4()));
 
     // The order of adding the vertices to the array is chosen so that clockwise / counter-clockwise orientation is retained.
 
     numVerticesInClippedQuad = 0;
 
@@ skipping 83 matching lines @@
 
     if (!h4.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, h4.cartesianPoint2d());
 
     if (h4.shouldBeClipped() ^ h1.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, computeClippedPointForEdge(h4, h1).cartesianPoint2d());
 
     return gfx::RectF(gfx::PointF(xmin, ymin), gfx::SizeF(xmax - xmin, ymax - ymin));
 }
 
-gfx::QuadF MathUtil::mapQuad(const WebTransformationMatrix& transform, const gfx::QuadF& q, bool& clipped)
+gfx::QuadF MathUtil::mapQuad(const Transform& transform, const gfx::QuadF& q, bool& clipped)
 {
-    if (transform.isIdentityOrTranslation()) {
+    if (MathUtil::isIdentityOrTranslation(transform)) {
         gfx::QuadF mappedQuad(q);
-        mappedQuad += gfx::Vector2dF(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
+        mappedQuad += gfx::Vector2dF(static_cast<float>(transform.matrix().getDouble(0, 3)), static_cast<float>(transform.matrix().getDouble(1, 3)));
         clipped = false;
         return mappedQuad;
     }
 
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, gfx::Point3F(q.p1()));
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, gfx::Point3F(q.p2()));
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, gfx::Point3F(q.p3()));
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, gfx::Point3F(q.p4()));
 
     clipped = h1.shouldBeClipped() || h2.shouldBeClipped() || h3.shouldBeClipped() || h4.shouldBeClipped();
 
     // Result will be invalid if clipped == true. But, compute it anyway just in case, to emulate existing behavior.
     return gfx::QuadF(h1.cartesianPoint2d(), h2.cartesianPoint2d(), h3.cartesianPoint2d(), h4.cartesianPoint2d());
 }
 
-gfx::PointF MathUtil::mapPoint(const WebTransformationMatrix& transform, const gfx::PointF& p, bool& clipped)
+gfx::PointF MathUtil::mapPoint(const Transform& transform, const gfx::PointF& p, bool& clipped)
 {
     HomogeneousCoordinate h = mapHomogeneousPoint(transform, gfx::Point3F(p));
 
     if (h.w > 0) {
         clipped = false;
         return h.cartesianPoint2d();
     }
 
     // The cartesian coordinates will be invalid after dividing by w.
     clipped = true;
 
     // Avoid dividing by w if w == 0.
     if (!h.w)
         return gfx::PointF();
 
     // This return value will be invalid because clipped == true, but (1) users of this
     // code should be ignoring the return value when clipped == true anyway, and (2) this
     // behavior is more consistent with existing behavior of WebKit transforms if the user
     // really does not ignore the return value.
     return h.cartesianPoint2d();
 }
 
-gfx::Point3F MathUtil::mapPoint(const WebTransformationMatrix& transform, const gfx::Point3F& p, bool& clipped)
+gfx::Point3F MathUtil::mapPoint(const Transform& transform, const gfx::Point3F& p, bool& clipped)
 {
     HomogeneousCoordinate h = mapHomogeneousPoint(transform, p);
 
     if (h.w > 0) {
         clipped = false;
         return h.cartesianPoint3d();
     }
 
     // The cartesian coordinates will be invalid after dividing by w.
     clipped = true;
 
     // Avoid dividing by w if w == 0.
     if (!h.w)
         return gfx::Point3F();
 
     // This return value will be invalid because clipped == true, but (1) users of this
     // code should be ignoring the return value when clipped == true anyway, and (2) this
     // behavior is more consistent with existing behavior of WebKit transforms if the user
     // really does not ignore the return value.
     return h.cartesianPoint3d();
 }
 
-gfx::QuadF MathUtil::projectQuad(const WebTransformationMatrix& transform, const gfx::QuadF& q, bool& clipped)
+gfx::QuadF MathUtil::projectQuad(const Transform& transform, const gfx::QuadF& q, bool& clipped)
 {
     gfx::QuadF projectedQuad;
     bool clippedPoint;
     projectedQuad.set_p1(projectPoint(transform, q.p1(), clippedPoint));
     clipped = clippedPoint;
     projectedQuad.set_p2(projectPoint(transform, q.p2(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.set_p3(projectPoint(transform, q.p3(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.set_p4(projectPoint(transform, q.p4(), clippedPoint));
     clipped |= clippedPoint;
 
     return projectedQuad;
 }
 
-gfx::PointF MathUtil::projectPoint(const WebTransformationMatrix& transform, const gfx::PointF& p, bool& clipped)
+gfx::PointF MathUtil::projectPoint(const Transform& transform, const gfx::PointF& p, bool& clipped)
 {
     HomogeneousCoordinate h = projectHomogeneousPoint(transform, p);
 
     if (h.w > 0) {
         // The cartesian coordinates will be valid in this case.
         clipped = false;
         return h.cartesianPoint2d();
     }
 
     // The cartesian coordinates will be invalid after dividing by w.
     clipped = true;
 
     // Avoid dividing by w if w == 0.
     if (!h.w)
         return gfx::PointF();
 
     // This return value will be invalid because clipped == true, but (1) users of this
     // code should be ignoring the return value when clipped == true anyway, and (2) this
     // behavior is more consistent with existing behavior of WebKit transforms if the user
     // really does not ignore the return value.
     return h.cartesianPoint2d();
 }
 
-void MathUtil::flattenTransformTo2d(WebTransformationMatrix& transform)
+void MathUtil::flattenTransformTo2d(Transform& transform)
 {
     // Set both the 3rd row and 3rd column to (0, 0, 1, 0).
     //
     // One useful interpretation of doing this operation:
     //  - For x and y values, the new transform behaves effectively like an orthographic
     //    projection was added to the matrix sequence.
     //  - For z values, the new transform overrides any effect that the transform had on
     //    z, and instead it preserves the z value for any points that are transformed.
     //  - Because of linearity of transforms, this flattened transform also preserves the
     //    effect that any subsequent (post-multiplied) transforms would have on z values.
     //
-    transform.setM13(0);
-    transform.setM23(0);
-    transform.setM31(0);
-    transform.setM32(0);
-    transform.setM33(1);
-    transform.setM34(0);
-    transform.setM43(0);
+    transform.matrix().setDouble(2, 0, 0);
+    transform.matrix().setDouble(2, 1, 0);
+    transform.matrix().setDouble(0, 2, 0);
+    transform.matrix().setDouble(1, 2, 0);
+    transform.matrix().setDouble(2, 2, 1);
+    transform.matrix().setDouble(3, 2, 0);
+    transform.matrix().setDouble(2, 3, 0);
 }
 
 static inline float scaleOnAxis(double a, double b, double c)
 {
     return std::sqrt(a * a + b * b + c * c);
 }
 
-gfx::Vector2dF MathUtil::computeTransform2dScaleComponents(const WebTransformationMatrix& transform)
+gfx::Vector2dF MathUtil::computeTransform2dScaleComponents(const Transform& transform)
 {
-    if (transform.hasPerspective())
+    if (hasPerspective(transform))
         return gfx::Vector2dF(1, 1);
-    float xScale = scaleOnAxis(transform.m11(), transform.m12(), transform.m13());
-    float yScale = scaleOnAxis(transform.m21(), transform.m22(), transform.m23());
+    float xScale = scaleOnAxis(transform.matrix().getDouble(0, 0), transform.matrix().getDouble(1, 0), transform.matrix().getDouble(2, 0));
+    float yScale = scaleOnAxis(transform.matrix().getDouble(0, 1), transform.matrix().getDouble(1, 1), transform.matrix().getDouble(2, 1));
     return gfx::Vector2dF(xScale, yScale);
 }
 
 float MathUtil::smallestAngleBetweenVectors(gfx::Vector2dF v1, gfx::Vector2dF v2)
 {
     double dotProduct = gfx::DotProduct(v1, v2) / v1.Length() / v2.Length();
     // Clamp to compensate for rounding errors.
     dotProduct = std::max(-1.0, std::min(1.0, dotProduct));
     return static_cast<float>(Rad2Deg(std::acos(dotProduct)));
 }
 
 gfx::Vector2dF MathUtil::projectVector(gfx::Vector2dF source, gfx::Vector2dF destination)
 {
     float projectedLength = gfx::DotProduct(source, destination) / destination.LengthSquared();
     return gfx::Vector2dF(projectedLength * destination.x(), projectedLength * destination.y());
 }
 
-bool MathUtil::isInvertible(const gfx::Transform& transform)
+bool MathUtil::isBackFaceVisible(const gfx::Transform& transform)
 {
-    const SkMatrix44& matrix = transform.matrix();
-    double determinant = matrix.determinant();
-    return abs(determinant) > EPSILON;
-}
+    // Compute whether a layer with a forward-facing normal of (0, 0, 1) would
+    // have its back face visible after applying the transform.
+    //
+    // This is done by transforming the normal and seeing if the resulting z
+    // value is positive or negative. However, note that transforming a normal
+    // actually requires using the inverse-transpose of the original transform.
 
-bool MathUtil::isBackFaceVisible(const gfx::Transform&)
-{
-    // TODO (shawnsingh): to be implemented in a follow up patch very soon.
-    NOTREACHED();
-    return false;
-}
+    // TODO (shawnsingh) make this perform more efficiently - we do not
+    // actually need to instantiate/invert/transpose any matrices, exploiting the
+    // fact that we only need to transform (0, 0, 1, 0).
+    gfx::Transform inverseTransform = MathUtil::inverse(transform);
+    const SkMatrix44& mInv = inverseTransform.matrix();
 
-bool MathUtil::isIdentity(const gfx::Transform& transform)
-{
-    return transform.matrix().isIdentity();
+    return mInv.getDouble(2, 2) < 0;

[danakj, 2012/11/24 02:34:54]

This is a lot simpler than WebCore::TransformationMatrix's equivalent method..
how come?

[shawnsingh, 2012/11/24 02:56:14]

The difference is in the TODO.  We should be able to grab only a few
determinant/cofactor parts of the matrix instead of computing a full inverse. 
The WebCore version does that optimization, and I still have to do that here. 
There's a bit of API / design work that needs to be plumbed before we can do
that (the cofactor / determinant stuff in skia should probably be modified to
support this).

[danakj, 2012/11/24 03:20:09]

I see, okay.

 }
 
 bool MathUtil::isIdentityOrTranslation(const gfx::Transform& transform)
 {
     const SkMatrix44& matrix = transform.matrix();
 
     bool hasNoPerspective = !matrix.getDouble(3, 0) && !matrix.getDouble(3, 1) && !matrix.getDouble(3, 2) && (matrix.getDouble(3, 3) == 1);
     bool hasNoRotationOrSkew = !matrix.getDouble(0, 1) && !matrix.getDouble(0, 2) && !matrix.getDouble(1, 0) &&
         !matrix.getDouble(1, 2) && !matrix.getDouble(2, 0) && !matrix.getDouble(2, 1);
     bool hasNoScale = matrix.getDouble(0, 0) == 1 && matrix.getDouble(1, 1) == 1 && matrix.getDouble(2, 2) == 1;
 
     return hasNoPerspective && hasNoRotationOrSkew && hasNoScale;
 }
 
 bool MathUtil::hasPerspective(const gfx::Transform& transform)
 {
     // Mathematically it is a bit too strict to expect the 4th element to be
     // equal to 1. However, the only non-perspective case where this element
     // becomes non-1 is when it was explicitly initialized. In that case it
     // still causes us to have a nontrivial divide-by-w, so we count it as
     // being perspective here.
     const SkMatrix44& matrix = transform.matrix();
     return matrix.getDouble(3, 0) || matrix.getDouble(3, 1) || matrix.getDouble(3, 2) || (matrix.getDouble(3, 3) != 1);
 }
 
-void MathUtil::makeIdentity(gfx::Transform* transform)
-{
-    transform->matrix().setIdentity();
-}
-
 void MathUtil::rotateEulerAngles(gfx::Transform* transform, double eulerX, double eulerY, double eulerZ)
 {
     // TODO (shawnsingh): make this implementation faster and more accurate by
     // hard-coding each matrix instead of calling rotateAxisAngle().
     gfx::Transform rotationAboutX;
     gfx::Transform rotationAboutY;
     gfx::Transform rotationAboutZ;
 
     MathUtil::rotateAxisAngle(&rotationAboutX, 1, 0, 0, eulerX);
     MathUtil::rotateAxisAngle(&rotationAboutY, 0, 1, 0, eulerY);
@@ skipping 91 matching lines @@
 
 gfx::Transform operator*(const gfx::Transform& A, const gfx::Transform& B)
 {
     // Compute A * B.
     gfx::Transform result = A;
     result.PreconcatTransform(B);
     return result;
 }
 
 }  // namespace cc