Replace inverse transform with Cross-product computation.

cc/quads/draw_polygon.cc

 // Copyright 2014 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/quads/draw_polygon.h"
 
 #include <vector>
 
 #include "cc/output/bsp_compare_result.h"
 #include "cc/quads/draw_quad.h"
@@ skipping 52 matching lines @@
   // Doing this mapping here is very important, since we can't just transform
   // the points without clipping and not run into strange geometry issues when
   // crossing w = 0. At this point, in the constructor, we know that we're
   // working with a quad, so we can reuse the MathUtil::MapClippedQuad3d
   // function instead of writing a generic polygon version of it.
   MathUtil::MapClippedQuad3d(
       transform, send_quad, points, &num_vertices_in_clipped_quad);
   for (int i = 0; i < num_vertices_in_clipped_quad; i++) {
     points_.push_back(points[i]);
   }
-  ApplyTransformToNormal(transform);
+  ConstructNormal();
 }
 
 DrawPolygon::~DrawPolygon() {
 }
 
 scoped_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
   scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon());
   new_polygon->order_index_ = order_index_;
   new_polygon->original_ref_ = original_ref_;
   new_polygon->points_.reserve(points_.size());
   new_polygon->points_ = points_;
   new_polygon->normal_.set_x(normal_.x());
   new_polygon->normal_.set_y(normal_.y());
   new_polygon->normal_.set_z(normal_.z());
   return new_polygon;
 }
 
+//
+// If this were to be more generally used and expected to be applicable
+// replacing this with Newell's algorithm (or an improvement thereof)
+// would be preferable, but usually this is coming in from a rectangle
+// that has been transformed to screen space and clipped.
+// Averaging a few near diagonal cross products is pretty good in that case.
+//
+void DrawPolygon::ConstructNormal() {
+  normal_.set_x(0.0f);
+  normal_.set_y(0.0f);
+  normal_.set_z(0.0f);

[Peter Mayo, 2015/12/04 16:40:41]

What about saving the old normal and adding a fallback of inverting the
transformation?

+  int delta = points_.size() / 2;
+  for (size_t i = 1; i + delta < points_.size(); i++) {
+    normal_ +=
+        CrossProduct(points_[i] - points_[0], points_[i + delta] - points_[0]);
+  }
+  float normal_magnitude = normal_.Length();
+  if (normal_magnitude != 0 && normal_magnitude != 1) {
+    normal_.Scale(1.0f / normal_magnitude);
+  }
+}
+
 float DrawPolygon::SignedPointDistance(const gfx::Point3F& point) const {
   return gfx::DotProduct(point - points_[0], normal_);
 }
 
 // Checks whether or not shape a lies on the front or back side of b, or
 // whether they should be considered coplanar. If on the back side, we
 // say A_BEFORE_B because it should be drawn in that order.
 // Assumes that layers are split and there are no intersecting planes.
 BspCompareResult DrawPolygon::SideCompare(const DrawPolygon& a,
                                           const DrawPolygon& b) {
@@ skipping 102 matching lines @@
   for (size_t i = 0; i < points_.size(); i++) {
     transform.TransformPoint(&points_[i]);
   }
 }
 
 // TransformToScreenSpace assumes we're moving a layer from its layer space
 // into 3D screen space, which for sorting purposes requires the normal to
 // be transformed along with the vertices.
 void DrawPolygon::TransformToScreenSpace(const gfx::Transform& transform) {
   ApplyTransform(transform);
-  ApplyTransformToNormal(transform);
+  ConstructNormal();
 }
 
 // In the case of TransformToLayerSpace, we assume that we are giving the
 // inverse transformation back to the polygon to move it back into layer space
 // but we can ignore the costly process of applying the inverse to the normal
 // since we know the normal will just reset to its original state.
 void DrawPolygon::TransformToLayerSpace(
     const gfx::Transform& inverse_transform) {
   ApplyTransform(inverse_transform);
   normal_ = gfx::Vector3dF(0.0f, 0.0f, -1.0f);
@@ skipping 106 matching lines @@
     quads->push_back(
         gfx::QuadF(first,
                    gfx::PointF(points_[offset].x(), points_[offset].y()),
                    gfx::PointF(points_[op1].x(), points_[op1].y()),
                    gfx::PointF(points_[op2].x(), points_[op2].y())));
     offset = op2;
   }
 }
 
 }  // namespace cc