Splitting of layers for correct intersections

cc/output/direct_renderer.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/output/direct_renderer.h"
 
+#include <hash_map>
+#include <list>
+#include <set>
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/base/math_util.h"
+#include "cc/output/bsp_tree.h"
+#include "cc/output/bsp_walk_action.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/draw_quad.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 static gfx::Transform OrthoProjectionMatrix(float left,
                                             float right,
                                             float bottom,
                                             float top) {
   // Use the standard formula to map the clipping frustum to the cube from
@@ skipping 267 matching lines @@
     return;
   }
   if (NeedDeviceClip(frame)) {
     SetScissorTestRect(DeviceClipRectInWindowSpace(frame));
     return;
   }
 
   EnsureScissorTestDisabled();
 }
 
+bool DirectRenderer::ShouldSkipQuad(
+      const DrawQuad& quad,
+      const gfx::Rect& render_pass_scissor
+  ) {
+  if(render_pass_scissor.IsEmpty())
+    return true;
+
+  if (quad.isClipped()) {
+    gfx::Rect r = quad.clipRect();
+    r.Intersect(render_pass_scissor);
+    return r.IsEmpty();
+  }
+
+  return false;
+}
+
+
 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
     const DrawingFrame* frame,
     const DrawQuad& quad,
-    const gfx::Rect& render_pass_scissor,
-    bool* should_skip_quad) {
+    const gfx::Rect& render_pass_scissor) {
   gfx::Rect quad_scissor_rect = render_pass_scissor;
-
   if (quad.isClipped())
     quad_scissor_rect.Intersect(quad.clipRect());
-
-  if (quad_scissor_rect.IsEmpty()) {
-    *should_skip_quad = true;
-    return;
-  }
-
-  *should_skip_quad = false;
   SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
 }
 
 void DirectRenderer::SetScissorTestRectInDrawSpace(
     const DrawingFrame* frame,
     const gfx::Rect& draw_space_rect) {
   gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
   if (NeedDeviceClip(frame))
     window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
   SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
+void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly,
+                                   DrawingFrame* frame,
+                                   const gfx::Rect& render_pass_scissor,
+                                   bool using_scissor_as_optimization) {
+  if (using_scissor_as_optimization) {
+      SetScissorStateForQuadWithRenderPassScissor(
+          frame, *poly.original_ref(), render_pass_scissor);
+  } else {
+      SetScissorStateForQuad(frame, *poly.original_ref());
+  }
+  std::vector<gfx::QuadF> quads;
+  poly.ToQuads2D(&quads);
+  for (unsigned int i = 0; i < quads.size(); ++i) {
+    DoDrawQuad(frame, poly.original_ref(), &quads[i]);
+  }
+}
+
+void DirectRenderer::FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list,
+                                   DrawingFrame* frame,
+                                   const gfx::Rect& render_pass_scissor,
+                                   bool using_scissor_as_optimization) {
+  if (poly_list->size() == 0) {
+    return;
+  }
+
+  BspTree bsp_tree(poly_list);
+  // Very important to use a new list here because we're relying on the old
+  // list to be intact for cleanup
+  BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
+                                          using_scissor_as_optimization);
+  bsp_tree.TraverseWithActionHandler(&action_handler);
+  // Clear the polygon list for the next transformation layer block
+  poly_list->clear();
+}
+
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization = Capabilities().using_partial_swap;
   gfx::Rect render_pass_scissor;
   bool draw_rect_covers_full_surface = true;
   if (frame->current_render_pass == frame->root_render_pass &&
@@ skipping 19 matching lines @@
 
     bool has_external_stencil_test =
         output_surface_->HasExternalStencilTest() &&
         frame->current_render_pass == frame->root_render_pass;
 
     DiscardPixels(has_external_stencil_test, draw_rect_covers_full_surface);
     ClearFramebuffer(frame, has_external_stencil_test);
   }
 
   const QuadList& quad_list = render_pass->quad_list;
+  ScopedPtrDeque<DrawPolygon> poly_list;
+
+  int count = 0;
+  int last_context_id = 0;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
-    const DrawQuad& quad = *(*it);
-    bool should_skip_quad = false;
+    DrawQuad& quad = *(*it);
+    gfx::QuadF send_quad(quad.visible_rect);
+    gfx::Transform quad_transform = quad.quadTransform();
+
+    if (using_scissor_as_optimization) {
+      if (ShouldSkipQuad(quad, render_pass_scissor)) {
+        continue;
+      }
+    }
+    if (last_context_id != quad.shared_quad_state->sorting_context_id) {
+      last_context_id = quad.shared_quad_state->sorting_context_id;
+      FlushPolygons(&poly_list, frame,
+                    render_pass_scissor, using_scissor_as_optimization);
+    }
+
+    // This layer is in a 3D sorting context so we add it to the list of
+    // polygons to go into the BSP tree.
+    if (quad.shared_quad_state->sorting_context_id != 0) {
+      scoped_ptr<DrawPolygon> new_polygon(
+          new DrawPolygon(*it, quad.visible_rect, quad_transform, count++));
+      if (new_polygon->points().size() > 2u) {
+        poly_list.push_back(new_polygon.Pass());
+      }
+      continue;
+    }
 
     if (using_scissor_as_optimization) {
       SetScissorStateForQuadWithRenderPassScissor(
-          frame, quad, render_pass_scissor, &should_skip_quad);
+          frame, quad, render_pass_scissor);
     } else {
       SetScissorStateForQuad(frame, quad);
     }
-
-    if (!should_skip_quad)
-      DoDrawQuad(frame, *it);
+    // Go ahead and draw the flat layers as normal and reset the draw mode
+    // flag to show that we're now drawing flat layers
+    DoDrawQuad(frame, *it);
   }
+  FlushPolygons(&poly_list, frame,
+                render_pass_scissor, using_scissor_as_optimization);
   FinishDrawingQuadList();
 }
 
 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
                                    const RenderPass* render_pass) {
   frame->current_render_pass = render_pass;
   frame->current_texture = NULL;
 
   if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
@@ skipping 22 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc