src/cc/layers/render_surface_impl.cc

   1 // Copyright 2011 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/layers/render_surface_impl.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "cc/base/math_util.h"
  12 #include "cc/debug/debug_colors.h"
  13 #include "cc/layers/delegated_renderer_layer_impl.h"
  14 #include "cc/layers/layer_impl.h"
  15 #include "cc/layers/quad_sink.h"
  16 #include "cc/layers/render_pass_sink.h"
  17 #include "cc/quads/debug_border_draw_quad.h"
  18 #include "cc/quads/render_pass.h"
  19 #include "cc/quads/render_pass_draw_quad.h"
  20 #include "cc/quads/shared_quad_state.h"
  21 #include "cc/trees/damage_tracker.h"
  22 #include "third_party/skia/include/core/SkImageFilter.h"
  23 #include "ui/gfx/rect_conversions.h"
  24 #include "ui/gfx/transform.h"
  25
  26 namespace cc {
  27
  28 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
  29     : owning_layer_(owning_layer),
  30       surface_property_changed_(false),
  31       draw_opacity_is_animating_(false),
  32       target_surface_transforms_are_animating_(false),
  33       screen_space_transforms_are_animating_(false),
  34       is_clipped_(false),
  35       contributes_to_drawn_surface_(false),
  36       draw_opacity_(1),
  37       nearest_occlusion_immune_ancestor_(NULL),
  38       target_render_surface_layer_index_history_(0),
  39       current_layer_index_history_(0) {
  40   damage_tracker_ = DamageTracker::Create();
  41 }
  42
  43 RenderSurfaceImpl::~RenderSurfaceImpl() {}
  44
  45 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
  46   gfx::RectF drawable_content_rect =
  47       MathUtil::MapClippedRect(draw_transform_, content_rect_);
  48   if (owning_layer_->has_replica()) {
  49     drawable_content_rect.Union(
  50         MathUtil::MapClippedRect(replica_draw_transform_, content_rect_));
  51   }
  52
  53   return drawable_content_rect;
  54 }
  55
  56 int RenderSurfaceImpl::OwningLayerId() const {
  57   return owning_layer_ ? owning_layer_->id() : 0;
  58 }
  59
  60
  61 void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) {
  62   if (clip_rect_ == clip_rect)
  63     return;
  64
  65   surface_property_changed_ = true;
  66   clip_rect_ = clip_rect;
  67 }
  68
  69 bool RenderSurfaceImpl::ContentsChanged() const {
  70   return !damage_tracker_->current_damage_rect().IsEmpty();
  71 }
  72
  73 void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) {
  74   if (content_rect_ == content_rect)
  75     return;
  76
  77   surface_property_changed_ = true;
  78   content_rect_ = content_rect;
  79 }
  80
  81 bool RenderSurfaceImpl::SurfacePropertyChanged() const {
  82   // Surface property changes are tracked as follows:
  83   //
  84   // - surface_property_changed_ is flagged when the clip_rect or content_rect
  85   //   change. As of now, these are the only two properties that can be affected
  86   //   by descendant layers.
  87   //
  88   // - all other property changes come from the owning layer (or some ancestor
  89   //   layer that propagates its change to the owning layer).
  90   //
  91   DCHECK(owning_layer_);
  92   return surface_property_changed_ || owning_layer_->LayerPropertyChanged();
  93 }
  94
  95 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
  96   return surface_property_changed_ && !owning_layer_->LayerPropertyChanged();
  97 }
  98
  99 void RenderSurfaceImpl::AddContributingDelegatedRenderPassLayer(
 100     LayerImpl* layer) {
 101   DCHECK(std::find(layer_list_.begin(), layer_list_.end(), layer) !=
 102          layer_list_.end());
 103   DelegatedRendererLayerImpl* delegated_renderer_layer =
 104       static_cast<DelegatedRendererLayerImpl*>(layer);
 105   contributing_delegated_render_pass_layer_list_.push_back(
 106       delegated_renderer_layer);
 107 }
 108
 109 void RenderSurfaceImpl::ClearLayerLists() {
 110   layer_list_.clear();
 111   contributing_delegated_render_pass_layer_list_.clear();
 112 }
 113
 114 RenderPass::Id RenderSurfaceImpl::RenderPassId() {
 115   int layer_id = owning_layer_->id();
 116   int sub_id = 0;
 117   DCHECK_GT(layer_id, 0);
 118   return RenderPass::Id(layer_id, sub_id);
 119 }
 120
 121 void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) {
 122   for (size_t i = 0;
 123        i < contributing_delegated_render_pass_layer_list_.size();
 124        ++i) {
 125     DelegatedRendererLayerImpl* delegated_renderer_layer =
 126         contributing_delegated_render_pass_layer_list_[i];
 127     delegated_renderer_layer->AppendContributingRenderPasses(pass_sink);
 128   }
 129
 130   scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
 131   pass->SetNew(RenderPassId(),
 132                content_rect_,
 133                gfx::IntersectRects(content_rect_,
 134                                    damage_tracker_->current_damage_rect()),
 135                screen_space_transform_);
 136   pass_sink->AppendRenderPass(pass.Pass());
 137 }
 138
 139 void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
 140                                     AppendQuadsData* append_quads_data,
 141                                     bool for_replica,
 142                                     RenderPass::Id render_pass_id) {
 143   DCHECK(!for_replica || owning_layer_->has_replica());
 144
 145   const gfx::Transform& draw_transform =
 146       for_replica ? replica_draw_transform_ : draw_transform_;
 147   gfx::Rect visible_content_rect =
 148       quad_sink->UnoccludedContributingSurfaceContentRect(content_rect_,
 149                                                           draw_transform);
 150   if (visible_content_rect.IsEmpty())
 151     return;
 152
 153   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
 154   shared_quad_state->SetAll(draw_transform,
 155                             content_rect_.size(),
 156                             content_rect_,
 157                             clip_rect_,
 158                             is_clipped_,
 159                             draw_opacity_,
 160                             owning_layer_->blend_mode());
 161
 162   if (owning_layer_->ShowDebugBorders()) {
 163     SkColor color = for_replica ?
 164                     DebugColors::SurfaceReplicaBorderColor() :
 165                     DebugColors::SurfaceBorderColor();
 166     float width = for_replica ?
 167                   DebugColors::SurfaceReplicaBorderWidth(
 168                       owning_layer_->layer_tree_impl()) :
 169                   DebugColors::SurfaceBorderWidth(
 170                       owning_layer_->layer_tree_impl());
 171     scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
 172         DebugBorderDrawQuad::Create();
 173     debug_border_quad->SetNew(
 174         shared_quad_state, content_rect_, visible_content_rect, color, width);
 175     quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
 176   }
 177
 178   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
 179   // and its reflection, it's currently not possible to apply a separate mask to
 180   // the reflection layer or correctly handle opacity in reflections (opacity
 181   // must be applied after drawing both the layer and its reflection). The
 182   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
 183   // and its reflection in. For now we only apply a separate reflection mask if
 184   // the contents don't have a mask of their own.
 185   LayerImpl* mask_layer = owning_layer_->mask_layer();
 186   if (mask_layer &&
 187       (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
 188     mask_layer = NULL;
 189
 190   if (!mask_layer && for_replica) {
 191     mask_layer = owning_layer_->replica_layer()->mask_layer();
 192     if (mask_layer &&
 193         (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
 194       mask_layer = NULL;
 195   }
 196
 197   gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
 198   if (mask_layer) {
 199     gfx::Vector2dF owning_layer_draw_scale =
 200         MathUtil::ComputeTransform2dScaleComponents(
 201             owning_layer_->draw_transform(), 1.f);
 202     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
 203         owning_layer_->content_bounds(),
 204         owning_layer_draw_scale.x(),
 205         owning_layer_draw_scale.y());
 206
 207     float uv_scale_x =
 208         content_rect_.width() / unclipped_mask_target_size.width();
 209     float uv_scale_y =
 210         content_rect_.height() / unclipped_mask_target_size.height();
 211
 212     mask_uv_rect = gfx::RectF(
 213         uv_scale_x * content_rect_.x() / content_rect_.width(),
 214         uv_scale_y * content_rect_.y() / content_rect_.height(),
 215         uv_scale_x,
 216         uv_scale_y);
 217   }
 218
 219   ResourceProvider::ResourceId mask_resource_id =
 220       mask_layer ? mask_layer->ContentsResourceId() : 0;
 221   gfx::Rect contents_changed_since_last_frame =
 222       ContentsChanged() ? content_rect_ : gfx::Rect();
 223
 224   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 225   quad->SetNew(shared_quad_state,
 226                content_rect_,
 227                visible_content_rect,
 228                render_pass_id,
 229                for_replica,
 230                mask_resource_id,
 231                contents_changed_since_last_frame,
 232                mask_uv_rect,
 233                owning_layer_->filters(),
 234                owning_layer_->background_filters());
 235   quad_sink->Append(quad.PassAs<DrawQuad>());
 236 }
 237
 238 }  // namespace cc