cc: Rename cc classes and members to match filenames

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 "config.h"
 
 #include "CCMathUtil.h"
 
 #include "FloatPoint.h"
 #include "FloatQuad.h"
@@ skipping 77 matching lines @@
     ymin = std::min(p.y(), ymin);
     ymax = std::max(p.y(), ymax);
 }
 
 static inline void addVertexToClippedQuad(const FloatPoint& newVertex, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad)
 {
     clippedQuad[numVerticesInClippedQuad] = newVertex;
     numVerticesInClippedQuad++;
 }
 
-IntRect CCMathUtil::mapClippedRect(const WebTransformationMatrix& transform, const IntRect& srcRect)
+IntRect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const IntRect& srcRect)
 {
     return enclosingIntRect(mapClippedRect(transform, FloatRect(srcRect)));
 }
 
-FloatRect CCMathUtil::mapClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
+FloatRect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
 {
     if (transform.isIdentityOrTranslation()) {
         FloatRect mappedRect(srcRect);
         mappedRect.move(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
         return mappedRect;
     }
 
     // Apply the transform, but retain the result in homogeneous coordinates.
     FloatQuad q = FloatQuad(FloatRect(srcRect));
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, q.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, q.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, q.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, q.p4());
 
     return computeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
-FloatRect CCMathUtil::projectClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
+FloatRect MathUtil::projectClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
 {
     // Perform the projection, but retain the result in homogeneous coordinates.
     FloatQuad q = FloatQuad(FloatRect(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 CCMathUtil::mapClippedQuad(const WebTransformationMatrix& transform, const FloatQuad& srcQuad, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad)
+void MathUtil::mapClippedQuad(const WebTransformationMatrix& transform, const FloatQuad& srcQuad, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad)
 {
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, srcQuad.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, srcQuad.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, srcQuad.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, srcQuad.p4());
 
     // The order of adding the vertices to the array is chosen so that clockwise / counter-clockwise orientation is retained.
 
     numVerticesInClippedQuad = 0;
 
@@ skipping 17 matching lines @@
 
     if (!h4.shouldBeClipped())
         addVertexToClippedQuad(h4.cartesianPoint2d(), clippedQuad, numVerticesInClippedQuad);
 
     if (h4.shouldBeClipped() ^ h1.shouldBeClipped())
         addVertexToClippedQuad(computeClippedPointForEdge(h4, h1).cartesianPoint2d(), clippedQuad, numVerticesInClippedQuad);
 
     ASSERT(numVerticesInClippedQuad <= 8);
 }
 
-FloatRect CCMathUtil::computeEnclosingRectOfVertices(FloatPoint vertices[], int numVertices)
+FloatRect MathUtil::computeEnclosingRectOfVertices(FloatPoint vertices[], int numVertices)
 {
     if (numVertices < 2)
         return FloatRect();
 
     float xmin = std::numeric_limits<float>::max();
     float xmax = -std::numeric_limits<float>::max();
     float ymin = std::numeric_limits<float>::max();
     float ymax = -std::numeric_limits<float>::max();
 
     for (int i = 0; i < numVertices; ++i)
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, vertices[i]);
 
     return FloatRect(FloatPoint(xmin, ymin), FloatSize(xmax - xmin, ymax - ymin));
 }
 
-FloatRect CCMathUtil::computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4)
+FloatRect MathUtil::computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4)
 {
     // This function performs clipping as necessary and computes the enclosing 2d
     // FloatRect of the vertices. Doing these two steps simultaneously allows us to avoid
     // the overhead of storing an unknown number of clipped vertices.
 
     // If no vertices on the quad are clipped, then we can simply return the enclosing rect directly.
     bool somethingClipped = h1.shouldBeClipped() || h2.shouldBeClipped() || h3.shouldBeClipped() || h4.shouldBeClipped();
     if (!somethingClipped) {
         FloatQuad mappedQuad = FloatQuad(h1.cartesianPoint2d(), h2.cartesianPoint2d(), h3.cartesianPoint2d(), h4.cartesianPoint2d());
         return mappedQuad.boundingBox();
@@ skipping 29 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 FloatRect(FloatPoint(xmin, ymin), FloatSize(xmax - xmin, ymax - ymin));
 }
 
-FloatQuad CCMathUtil::mapQuad(const WebTransformationMatrix& transform, const FloatQuad& q, bool& clipped)
+FloatQuad MathUtil::mapQuad(const WebTransformationMatrix& transform, const FloatQuad& q, bool& clipped)
 {
     if (transform.isIdentityOrTranslation()) {
         FloatQuad mappedQuad(q);
         mappedQuad.move(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
         clipped = false;
         return mappedQuad;
     }
 
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, q.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, q.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, q.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, 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 FloatQuad(h1.cartesianPoint2d(), h2.cartesianPoint2d(), h3.cartesianPoint2d(), h4.cartesianPoint2d());
 }
 
-FloatPoint CCMathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint& p, bool& clipped)
+FloatPoint MathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint& p, bool& clipped)
 {
     HomogeneousCoordinate h = mapHomogeneousPoint(transform, 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 FloatPoint();
 
     // 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();
 }
 
-FloatPoint3D CCMathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint3D& p, bool& clipped)
+FloatPoint3D MathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint3D& 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 FloatPoint3D();
 
     // 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();
 }
 
-FloatQuad CCMathUtil::projectQuad(const WebTransformationMatrix& transform, const FloatQuad& q, bool& clipped)
+FloatQuad MathUtil::projectQuad(const WebTransformationMatrix& transform, const FloatQuad& q, bool& clipped)
 {
     FloatQuad projectedQuad;
     bool clippedPoint;
     projectedQuad.setP1(projectPoint(transform, q.p1(), clippedPoint));
     clipped = clippedPoint;
     projectedQuad.setP2(projectPoint(transform, q.p2(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.setP3(projectPoint(transform, q.p3(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.setP4(projectPoint(transform, q.p4(), clippedPoint));
     clipped |= clippedPoint;
 
     return projectedQuad;
 }
 
-FloatPoint CCMathUtil::projectPoint(const WebTransformationMatrix& transform, const FloatPoint& p, bool& clipped)
+FloatPoint MathUtil::projectPoint(const WebTransformationMatrix& transform, const FloatPoint& 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 FloatPoint();
 
     // 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 CCMathUtil::flattenTransformTo2d(WebTransformationMatrix& transform)
+void MathUtil::flattenTransformTo2d(WebTransformationMatrix& 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);
 }
 
-float CCMathUtil::smallestAngleBetweenVectors(const FloatSize& v1, const FloatSize& v2)
+float MathUtil::smallestAngleBetweenVectors(const FloatSize& v1, const FloatSize& v2)
 {
     float dotProduct = (v1.width() * v2.width() + v1.height() * v2.height()) / (v1.diagonalLength() * v2.diagonalLength());
     // Clamp to compensate for rounding errors.
     dotProduct = std::max(-1.f, std::min(1.f, dotProduct));
     return rad2deg(acosf(dotProduct));
 }
 
-FloatSize CCMathUtil::projectVector(const FloatSize& source, const FloatSize& destination)
+FloatSize MathUtil::projectVector(const FloatSize& source, const FloatSize& destination)
 {
     float sourceDotDestination = source.width() * destination.width() + source.height() * destination.height();
     float projectedLength = sourceDotDestination / destination.diagonalLengthSquared();
     return FloatSize(projectedLength * destination.width(), projectedLength * destination.height());
 }
 
 } // namespace cc