cc/trees/quad_culler.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/trees/quad_culler.h"
   6
   7 #include "cc/debug/debug_colors.h"
   8 #include "cc/layers/append_quads_data.h"
   9 #include "cc/layers/layer_impl.h"
  10 #include "cc/quads/debug_border_draw_quad.h"
  11 #include "cc/quads/render_pass.h"
  12 #include "cc/trees/occlusion_tracker.h"
  13 #include "third_party/skia/include/core/SkColor.h"
  14 #include "ui/gfx/transform.h"
  15
  16 namespace cc {
  17
  18 QuadCuller::QuadCuller(QuadList* quad_list,
  19                        SharedQuadStateList* shared_quad_state_list,
  20                        const LayerImpl* layer,
  21                        const OcclusionTracker<LayerImpl>& occlusion_tracker,
  22                        bool for_surface)
  23     : quad_list_(quad_list),
  24       shared_quad_state_list_(shared_quad_state_list),
  25       layer_(layer),
  26       occlusion_tracker_(occlusion_tracker),
  27       current_shared_quad_state_(NULL),
  28       for_surface_(for_surface) {}
  29
  30 SharedQuadState* QuadCuller::UseSharedQuadState(
  31     scoped_ptr<SharedQuadState> shared_quad_state) {
  32   // TODO(danakj): If all quads are culled for the shared_quad_state, we can
  33   // drop it from the list.
  34   current_shared_quad_state_ = shared_quad_state.get();
  35   shared_quad_state_list_->push_back(shared_quad_state.Pass());
  36   return current_shared_quad_state_;
  37 }
  38
  39 gfx::Rect QuadCuller::UnoccludedContentRect(
  40     const gfx::Rect& content_rect,
  41     const gfx::Transform& draw_transform) {
  42   return occlusion_tracker_.UnoccludedContentRect(
  43       layer_->render_target(), content_rect, draw_transform);
  44 }
  45
  46 static inline bool AppendQuadInternal(
  47     scoped_ptr<DrawQuad> draw_quad,
  48     const gfx::Rect& culled_rect,
  49     QuadList* quad_list,
  50     const OcclusionTracker<LayerImpl>& occlusion_tracker,
  51     const LayerImpl* layer) {
  52   bool keep_quad = !culled_rect.IsEmpty();
  53   if (keep_quad) {
  54     draw_quad->visible_rect = culled_rect;
  55     quad_list->push_back(draw_quad.Pass());
  56   }
  57   return keep_quad;
  58 }
  59
  60 bool QuadCuller::MaybeAppend(scoped_ptr<DrawQuad> draw_quad) {
  61   DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_);
  62   DCHECK(!shared_quad_state_list_->empty());
  63   DCHECK(shared_quad_state_list_->back() == current_shared_quad_state_);
  64
  65   gfx::Rect culled_rect;
  66   if (for_surface_) {
  67     culled_rect = occlusion_tracker_.UnoccludedContributingSurfaceContentRect(
  68         layer_, false, draw_quad->visible_rect);
  69   } else {
  70     culled_rect =
  71         occlusion_tracker_.UnoccludedContentRect(layer_->render_target(),
  72                                                  draw_quad->visible_rect,
  73                                                  draw_quad->quadTransform());
  74   }
  75
  76   return AppendQuadInternal(
  77       draw_quad.Pass(), culled_rect, quad_list_, occlusion_tracker_, layer_);
  78 }
  79
  80 void QuadCuller::Append(scoped_ptr<DrawQuad> draw_quad) {
  81   DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_);
  82   DCHECK(!shared_quad_state_list_->empty());
  83   DCHECK(shared_quad_state_list_->back() == current_shared_quad_state_);
  84   DCHECK(!draw_quad->rect.IsEmpty());
  85   DCHECK(!draw_quad->visible_rect.IsEmpty());
  86   quad_list_->push_back(draw_quad.Pass());
  87 }
  88
  89 }  // namespace cc