reflow comments in platform/{transforms,weborigin}

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

 /*
  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 33 matching lines @@
 
 #if CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
 namespace blink {
 
 //
 // Supporting Math Functions
 //
-// This is a set of function from various places (attributed inline) to do things like
-// inversion and decomposition of a 4x4 matrix. They are used throughout the code
+// This is a set of function from various places (attributed inline) to do
+// things like inversion and decomposition of a 4x4 matrix. They are used
+// throughout the code
 //
 
 //
-// Adapted from Matrix Inversion by Richard Carling, Graphics Gems <http://tog.acm.org/GraphicsGems/index.html>.
+// Adapted from Matrix Inversion by Richard Carling, Graphics Gems
+// <http://tog.acm.org/GraphicsGems/index.html>.
 
-// EULA: The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code
-// as your own and resell it. Using the code is permitted in any program, product, or library, non-commercial
-// or commercial. Giving credit is not required, though is a nice gesture. The code comes as-is, and if there
-// are any flaws or problems with any Gems code, nobody involved with Gems - authors, editors, publishers, or
-// webmasters - are to be held responsible. Basically, don't be a jerk, and remember that anything free comes
-// with no guarantee.
+// EULA: The Graphics Gems code is copyright-protected. In other words, you
+// cannot claim the text of the code as your own and resell it. Using the code
+// is permitted in any program, product, or library, non-commercial or
+// commercial. Giving credit is not required, though is a nice gesture. The code
+// comes as-is, and if there are any flaws or problems with any Gems code,
+// nobody involved with Gems - authors, editors, publishers, or webmasters - are
+// to be held responsible. Basically, don't be a jerk, and remember that
+// anything free comes with no guarantee.
 
 // A clarification about the storage of matrix elements
 //
-// This class uses a 2 dimensional array internally to store the elements of the matrix.  The first index into
-// the array refers to the column that the element lies in; the second index refers to the row.
+// This class uses a 2 dimensional array internally to store the elements of the
+// matrix.  The first index into the array refers to the column that the element
+// lies in; the second index refers to the row.
 //
 // In other words, this is the layout of the matrix:
 //
 // | m_matrix[0][0] m_matrix[1][0] m_matrix[2][0] m_matrix[3][0] |
 // | m_matrix[0][1] m_matrix[1][1] m_matrix[2][1] m_matrix[3][1] |
 // | m_matrix[0][2] m_matrix[1][2] m_matrix[2][2] m_matrix[3][2] |
 // | m_matrix[0][3] m_matrix[1][3] m_matrix[2][3] m_matrix[3][3] |
 
 typedef double Vector4[4];
 typedef double Vector3[3];
@@ skipping 582 matching lines @@
   //
   // Given a plane with normal Pn, and a ray starting at point R0 and
   // with direction defined by the vector Rd, we can find the
   // intersection point as a distance d from R0 in units of Rd by:
   //
   // d = -dot (Pn', R0) / dot (Pn', Rd)
   if (clamped)
     *clamped = false;
 
   if (m33() == 0) {
-    // In this case, the projection plane is parallel to the ray we are trying to
-    // trace, and there is no well-defined value for the projection.
+    // In this case, the projection plane is parallel to the ray we are trying
+    // to trace, and there is no well-defined value for the projection.
     return FloatPoint();
   }
 
   double x = p.x();
   double y = p.y();
   double z = -(m13() * x + m23() * y + m43()) / m33();
 
   // FIXME: use multVecMatrix()
   double outX = x * m11() + y * m21() + z * m31() + m41();
   double outY = x * m12() + y * m22() + z * m32() + m42();
 
   double w = x * m14() + y * m24() + z * m34() + m44();
   if (w <= 0) {
-    // Using int max causes overflow when other code uses the projected point. To
-    // represent infinity yet reduce the risk of overflow, we use a large but
+    // Using int max causes overflow when other code uses the projected point.
+    // To represent infinity yet reduce the risk of overflow, we use a large but
     // not-too-large number here when clamping.
     const int largeNumber = 100000000 / kFixedPointDenominator;
     outX = copysign(largeNumber, outX);
     outY = copysign(largeNumber, outY);
     if (clamped)
       *clamped = true;
   } else if (w != 1) {
     outX /= w;
     outY /= w;
   }
@@ skipping 11 matching lines @@
   bool clamped4 = false;
 
   projectedQuad.setP1(projectPoint(q.p1(), &clamped1));
   projectedQuad.setP2(projectPoint(q.p2(), &clamped2));
   projectedQuad.setP3(projectPoint(q.p3(), &clamped3));
   projectedQuad.setP4(projectPoint(q.p4(), &clamped4));
 
   if (clamped)
     *clamped = clamped1 || clamped2 || clamped3 || clamped4;
 
-  // If all points on the quad had w < 0, then the entire quad would not be visible to the projected surface.
+  // If all points on the quad had w < 0, then the entire quad would not be
+  // visible to the projected surface.
   bool everythingWasClipped = clamped1 && clamped2 && clamped3 && clamped4;
   if (everythingWasClipped)
     return FloatQuad();
 
   return projectedQuad;
 }
 
 static float clampEdgeValue(float f) {
   ASSERT(!std::isnan(f));
   return clampTo(f, (-LayoutUnit::max() / 2).toFloat(),
@@ skipping 138 matching lines @@
                   rotation.angle);
 }
 
 TransformationMatrix& TransformationMatrix::rotate3d(double x,
                                                      double y,
                                                      double z,
                                                      double angle) {
   // Normalize the axis of rotation
   double length = std::sqrt(x * x + y * y + z * z);
   if (length == 0) {
-    // A direction vector that cannot be normalized, such as [0, 0, 0], will cause the rotation to not be applied.
+    // A direction vector that cannot be normalized, such as [0, 0, 0], will
+    // cause the rotation to not be applied.
     return *this;
   } else if (length != 1) {
     x /= length;
     y /= length;
     z /= length;
   }
 
   // Angles are in degrees. Switch to radians.
   angle = deg2rad(angle);
 
@@ skipping 41 matching lines @@
     mat.m_matrix[2][2] = 1.0;
     mat.m_matrix[0][3] = mat.m_matrix[1][3] = mat.m_matrix[2][3] = 0.0;
     mat.m_matrix[3][0] = mat.m_matrix[3][1] = mat.m_matrix[3][2] = 0.0;
     mat.m_matrix[3][3] = 1.0;
   } else {
     // This case is the rotation about an arbitrary unit vector.
     //
     // Formula is adapted from Wikipedia article on Rotation matrix,
     // http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
     //
-    // An alternate resource with the same matrix: http://www.fastgraph.com/makegames/3drotation/
+    // An alternate resource with the same matrix:
+    // http://www.fastgraph.com/makegames/3drotation/
     //
     double oneMinusCosTheta = 1 - cosTheta;
     mat.m_matrix[0][0] = cosTheta + x * x * oneMinusCosTheta;
     mat.m_matrix[0][1] = y * x * oneMinusCosTheta + z * sinTheta;
     mat.m_matrix[0][2] = z * x * oneMinusCosTheta - y * sinTheta;
     mat.m_matrix[1][0] = x * y * oneMinusCosTheta - z * sinTheta;
     mat.m_matrix[1][1] = cosTheta + y * y * oneMinusCosTheta;
     mat.m_matrix[1][2] = z * y * oneMinusCosTheta + x * sinTheta;
     mat.m_matrix[2][0] = x * z * oneMinusCosTheta + y * sinTheta;
     mat.m_matrix[2][1] = y * z * oneMinusCosTheta - x * sinTheta;
@@ skipping 225 matching lines @@
       "fmla v7.2d, v31.2d, v23.d[1]  \t\n"
 
       "st1 {v0.2d - v3.2d}, [x9], 64 \t\n"
       "st1 {v4.2d - v7.2d}, [x9]     \t\n"
       : [leftMatrix] "+r"(leftMatrix), [rightMatrix] "+r"(rightMatrix)
       :
       : "memory", "x9", "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
         "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "v0", "v1",
         "v2", "v3", "v4", "v5", "v6", "v7");
 #elif defined(TRANSFORMATION_MATRIX_USE_X86_64_SSE2)
-  // x86_64 has 16 XMM registers which is enough to do the multiplication fully in registers.
+  // x86_64 has 16 XMM registers which is enough to do the multiplication fully
+  // in registers.
   __m128d matrixBlockA = _mm_load_pd(&(m_matrix[0][0]));
   __m128d matrixBlockC = _mm_load_pd(&(m_matrix[1][0]));
   __m128d matrixBlockE = _mm_load_pd(&(m_matrix[2][0]));
   __m128d matrixBlockG = _mm_load_pd(&(m_matrix[3][0]));
 
   // First row.
   __m128d otherMatrixFirstParam = _mm_set1_pd(mat.m_matrix[0][0]);
   __m128d otherMatrixSecondParam = _mm_set1_pd(mat.m_matrix[0][1]);
   __m128d otherMatrixThirdParam = _mm_set1_pd(mat.m_matrix[0][2]);
   __m128d otherMatrixFourthParam = _mm_set1_pd(mat.m_matrix[0][3]);
@@ skipping 480 matching lines @@
       decomposition.translateZ, decomposition.scaleX, decomposition.scaleY,
       decomposition.scaleZ, decomposition.skewXY, decomposition.skewXZ,
       decomposition.skewYZ, decomposition.quaternionX,
       decomposition.quaternionY, decomposition.quaternionZ,
       decomposition.quaternionW, decomposition.perspectiveX,
       decomposition.perspectiveY, decomposition.perspectiveZ,
       decomposition.perspectiveW);
 }
 
 }  // namespace blink