cc: Stop converting Rect to QuadF to map to an enclosed rect.

cc/base/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/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 112 matching lines @@
   if (transform.IsIdentityOrIntegerTranslation()) {
     return src_rect +
            gfx::Vector2d(
                static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
                static_cast<int>(
                    SkMScalarToFloat(transform.matrix().get(1, 3))));
   }
   return gfx::ToEnclosingRect(MapClippedRect(transform, gfx::RectF(src_rect)));
 }
 
+gfx::Rect MathUtil::MapEnclosedClippedRect(const gfx::Transform& transform,
+                                           const gfx::Rect& src_rect) {
+  if (transform.IsIdentityOrIntegerTranslation()) {
+    return src_rect +
+           gfx::Vector2d(
+               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
+               static_cast<int>(
+                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+  }
+  return gfx::ToEnclosedRect(MapClippedRect(transform, gfx::RectF(src_rect)));
+}
+
+gfx::Rect MathUtil::MapEnclosedNonClippedRect(const gfx::Transform& transform,
+                                              const gfx::Rect& src_rect) {
+  if (transform.IsIdentityOrIntegerTranslation()) {
+    return src_rect +
+           gfx::Vector2d(
+               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
+               static_cast<int>(
+                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+  }
+
+  SkMScalar quad[4 * 2];  // input: 4 x 2D points
+  quad[0] = src_rect.x();
+  quad[1] = src_rect.y();
+  quad[2] = src_rect.right();
+  quad[3] = src_rect.y();
+  quad[4] = src_rect.right();
+  quad[5] = src_rect.bottom();
+  quad[6] = src_rect.x();
+  quad[7] = src_rect.bottom();
+
+  SkMScalar result[4 * 4];  // output: 4 x 4D homogeneous points
+  transform.matrix().map2(quad, 4, result);
+
+  HomogeneousCoordinate hc0(result[0], result[1], result[2], result[3]);
+  HomogeneousCoordinate hc1(result[4], result[5], result[6], result[7]);
+  HomogeneousCoordinate hc2(result[8], result[9], result[10], result[11]);
+  HomogeneousCoordinate hc3(result[12], result[13], result[14], result[15]);
+  DCHECK(!hc0.ShouldBeClipped());
+  DCHECK(!hc1.ShouldBeClipped());
+  DCHECK(!hc2.ShouldBeClipped());
+  DCHECK(!hc3.ShouldBeClipped());
+
+  gfx::QuadF mapped_quad = gfx::QuadF(hc0.CartesianPoint2d(),
+                                      hc1.CartesianPoint2d(),
+                                      hc2.CartesianPoint2d(),
+                                      hc3.CartesianPoint2d());
+  return gfx::ToEnclosedRect(mapped_quad.BoundingBox());
+}
+
 gfx::RectF MathUtil::MapClippedRect(const gfx::Transform& transform,
                                     const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation()) {
     return src_rect +
            gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
                           SkMScalarToFloat(transform.matrix().get(1, 3)));
   }
 
   // Apply the transform, but retain the result in homogeneous coordinates.
 
@@ skipping 23 matching lines @@
     return src_rect +
            gfx::Vector2d(
                static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
                static_cast<int>(
                    SkMScalarToFloat(transform.matrix().get(1, 3))));
   }
   return gfx::ToEnclosingRect(
       ProjectClippedRect(transform, gfx::RectF(src_rect)));
 }
 
+gfx::Rect MathUtil::ProjectEnclosedClippedRect(const gfx::Transform& transform,
+                                               const gfx::Rect& src_rect) {
+  if (transform.IsIdentityOrIntegerTranslation()) {
+    return src_rect +
+           gfx::Vector2d(
+               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
+               static_cast<int>(
+                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+  }
+  return gfx::ToEnclosedRect(
+      ProjectClippedRect(transform, gfx::RectF(src_rect)));
+}
+
+gfx::Rect MathUtil::ProjectEnclosedNonClippedRect(
+    const gfx::Transform& transform,
+    const gfx::Rect& src_rect) {
+  if (transform.IsIdentityOrIntegerTranslation()) {
+    return src_rect +
+           gfx::Vector2d(
+               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
+               static_cast<int>(
+                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+  }
+
+  // Perform the projection, but retain the result in homogeneous coordinates.
+  gfx::QuadF q = gfx::QuadF(src_rect);
+  HomogeneousCoordinate hc0 = ProjectHomogeneousPoint(transform, q.p1());
+  HomogeneousCoordinate hc1 = ProjectHomogeneousPoint(transform, q.p2());
+  HomogeneousCoordinate hc2 = ProjectHomogeneousPoint(transform, q.p3());
+  HomogeneousCoordinate hc3 = ProjectHomogeneousPoint(transform, q.p4());
+  DCHECK(!hc0.ShouldBeClipped());
+  DCHECK(!hc1.ShouldBeClipped());
+  DCHECK(!hc2.ShouldBeClipped());
+  DCHECK(!hc3.ShouldBeClipped());
+
+  gfx::QuadF projected_quad = gfx::QuadF(hc0.CartesianPoint2d(),
+                                         hc1.CartesianPoint2d(),
+                                         hc2.CartesianPoint2d(),
+                                         hc3.CartesianPoint2d());
+  return gfx::ToEnclosedRect(projected_quad.BoundingBox());

[enne (OOO), 2014/08/21 17:54:05]

This code was here before, but is this actually right? You're taking enclosed,
but "bounding box" is inherently an *enclosing* operation?

[danakj, 2014/08/21 17:58:08]

Ya, good point. I had this thought about everything being broken last night but
then I wrote a test and it didn't fail and I noticed, we only map/project and
intend to get an enclosed thing when Preserves2dAxisAlignment is true. So we
should be able to do something much less general in this method and DCHECK on
the transform.

+}
+
 gfx::RectF MathUtil::ProjectClippedRect(const gfx::Transform& transform,
                                         const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation()) {
     return src_rect +
            gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
                           SkMScalarToFloat(transform.matrix().get(1, 3)));
   }
 
   // Perform the projection, but retain the result in homogeneous coordinates.
   gfx::QuadF q = gfx::QuadF(src_rect);
@@ skipping 604 matching lines @@
 
 double MathUtil::AsDoubleSafely(double value) {
   return std::min(value, std::numeric_limits<double>::max());
 }
 
 float MathUtil::AsFloatSafely(float value) {
   return std::min(value, std::numeric_limits<float>::max());
 }
 
 }  // namespace cc