Correct normal computation for inverted polygons.

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 <stddef.h>
 
 #include <vector>
 
@@ skipping 27 matching lines @@
 
 DrawPolygon::DrawPolygon(const DrawQuad* original,
                          const std::vector<gfx::Point3F>& in_points,
                          const gfx::Vector3dF& normal,
                          int draw_order_index)
     : order_index_(draw_order_index), original_ref_(original), is_split_(true) {
   for (size_t i = 0; i < in_points.size(); i++) {
     points_.push_back(in_points[i]);
   }
   normal_ = normal;
+  DCHECK_LE((ConstructNormal(), (normal_ - normal).Length()),
+            normalized_threshold);
 }
 
 // This takes the original DrawQuad that this polygon should be based on,
 // a visible content rect to make the 4 corner points from, and a transformation
 // to move it and its normal into screen space.
 DrawPolygon::DrawPolygon(const DrawQuad* original_ref,
                          const gfx::RectF& visible_layer_rect,
                          const gfx::Transform& transform,
                          int draw_order_index)
     : normal_(0.0f, 0.0f, 1.0f),
       order_index_(draw_order_index),
       original_ref_(original_ref),
       is_split_(false) {
   gfx::Point3F points[8];
   int num_vertices_in_clipped_quad;
   gfx::QuadF send_quad(visible_layer_rect);
 
   // 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]);
   }
+  transform.TransformVector(&normal_);
   ConstructNormal();
 }
 
 DrawPolygon::~DrawPolygon() {
 }
 
 std::unique_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
   std::unique_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);
+  gfx::Vector3dF new_normal(0.0f, 0.0f, 0.0f);
   int delta = points_.size() / 2;
   for (size_t i = 1; i + delta < points_.size(); i++) {
-    normal_ +=
+    new_normal +=
         CrossProduct(points_[i] - points_[0], points_[i + delta] - points_[0]);
   }
-  float normal_magnitude = normal_.Length();
+  float normal_magnitude = new_normal.Length();
+  // Here we constrain the new normal to point in the same sense as the old one.
+  // This allows us to handle winding-reversing transforms better.
+  if (gfx::DotProduct(normal_, new_normal) < 0.0) {
+    normal_magnitude *= -1.0;
+  }
   if (normal_magnitude != 0 && normal_magnitude != 1) {
-    normal_.Scale(1.0f / normal_magnitude);
+    new_normal.Scale(1.0f / normal_magnitude);
   }
+  normal_ = new_normal;
 }
 
 #if defined(OS_WIN)
 //
 // Allows the unittest to invoke this for the more general constructor.
 //
 void DrawPolygon::RecomputeNormalForTesting() {
   ConstructNormal();
 }
 #endif
@@ skipping 113 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);
+  transform.TransformVector(&normal_);
   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);
@@ skipping 107 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