| OLD | NEW |
|---|
| (Empty) |
| 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/render_pass_sink.h" | |
| 16 #include "cc/quads/debug_border_draw_quad.h" | |
| 17 #include "cc/quads/render_pass.h" | |
| 18 #include "cc/quads/render_pass_draw_quad.h" | |
| 19 #include "cc/quads/shared_quad_state.h" | |
| 20 #include "cc/trees/damage_tracker.h" | |
| 21 #include "cc/trees/occlusion.h" | |
| 22 #include "third_party/skia/include/core/SkImageFilter.h" | |
| 23 #include "ui/gfx/geometry/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_(nullptr), | |
| 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 SkColor RenderSurfaceImpl::GetDebugBorderColor() const { | |
| 57 return DebugColors::SurfaceBorderColor(); | |
| 58 } | |
| 59 | |
| 60 SkColor RenderSurfaceImpl::GetReplicaDebugBorderColor() const { | |
| 61 return DebugColors::SurfaceReplicaBorderColor(); | |
| 62 } | |
| 63 | |
| 64 float RenderSurfaceImpl::GetDebugBorderWidth() const { | |
| 65 return DebugColors::SurfaceBorderWidth(owning_layer_->layer_tree_impl()); | |
| 66 } | |
| 67 | |
| 68 float RenderSurfaceImpl::GetReplicaDebugBorderWidth() const { | |
| 69 return DebugColors::SurfaceReplicaBorderWidth( | |
| 70 owning_layer_->layer_tree_impl()); | |
| 71 } | |
| 72 | |
| 73 int RenderSurfaceImpl::OwningLayerId() const { | |
| 74 return owning_layer_ ? owning_layer_->id() : 0; | |
| 75 } | |
| 76 | |
| 77 | |
| 78 void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) { | |
| 79 if (clip_rect_ == clip_rect) | |
| 80 return; | |
| 81 | |
| 82 surface_property_changed_ = true; | |
| 83 clip_rect_ = clip_rect; | |
| 84 } | |
| 85 | |
| 86 void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) { | |
| 87 if (content_rect_ == content_rect) | |
| 88 return; | |
| 89 | |
| 90 surface_property_changed_ = true; | |
| 91 content_rect_ = content_rect; | |
| 92 } | |
| 93 | |
| 94 bool RenderSurfaceImpl::SurfacePropertyChanged() const { | |
| 95 // Surface property changes are tracked as follows: | |
| 96 // | |
| 97 // - surface_property_changed_ is flagged when the clip_rect or content_rect | |
| 98 // change. As of now, these are the only two properties that can be affected | |
| 99 // by descendant layers. | |
| 100 // | |
| 101 // - all other property changes come from the owning layer (or some ancestor | |
| 102 // layer that propagates its change to the owning layer). | |
| 103 // | |
| 104 DCHECK(owning_layer_); | |
| 105 return surface_property_changed_ || owning_layer_->LayerPropertyChanged(); | |
| 106 } | |
| 107 | |
| 108 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const { | |
| 109 return surface_property_changed_ && !owning_layer_->LayerPropertyChanged(); | |
| 110 } | |
| 111 | |
| 112 void RenderSurfaceImpl::AddContributingDelegatedRenderPassLayer( | |
| 113 LayerImpl* layer) { | |
| 114 DCHECK(std::find(layer_list_.begin(), layer_list_.end(), layer) != | |
| 115 layer_list_.end()); | |
| 116 DelegatedRendererLayerImpl* delegated_renderer_layer = | |
| 117 static_cast<DelegatedRendererLayerImpl*>(layer); | |
| 118 contributing_delegated_render_pass_layer_list_.push_back( | |
| 119 delegated_renderer_layer); | |
| 120 } | |
| 121 | |
| 122 void RenderSurfaceImpl::ClearLayerLists() { | |
| 123 layer_list_.clear(); | |
| 124 contributing_delegated_render_pass_layer_list_.clear(); | |
| 125 } | |
| 126 | |
| 127 RenderPassId RenderSurfaceImpl::GetRenderPassId() { | |
| 128 int layer_id = owning_layer_->id(); | |
| 129 int sub_id = 0; | |
| 130 DCHECK_GT(layer_id, 0); | |
| 131 return RenderPassId(layer_id, sub_id); | |
| 132 } | |
| 133 | |
| 134 void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) { | |
| 135 for (size_t i = 0; | |
| 136 i < contributing_delegated_render_pass_layer_list_.size(); | |
| 137 ++i) { | |
| 138 DelegatedRendererLayerImpl* delegated_renderer_layer = | |
| 139 contributing_delegated_render_pass_layer_list_[i]; | |
| 140 delegated_renderer_layer->AppendContributingRenderPasses(pass_sink); | |
| 141 } | |
| 142 | |
| 143 scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size()); | |
| 144 pass->SetNew(GetRenderPassId(), | |
| 145 content_rect_, | |
| 146 gfx::IntersectRects(content_rect_, | |
| 147 damage_tracker_->current_damage_rect()), | |
| 148 screen_space_transform_); | |
| 149 pass_sink->AppendRenderPass(pass.Pass()); | |
| 150 } | |
| 151 | |
| 152 void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass, | |
| 153 const gfx::Transform& draw_transform, | |
| 154 const Occlusion& occlusion_in_content_space, | |
| 155 SkColor debug_border_color, | |
| 156 float debug_border_width, | |
| 157 LayerImpl* mask_layer, | |
| 158 AppendQuadsData* append_quads_data, | |
| 159 RenderPassId render_pass_id) { | |
| 160 gfx::Rect visible_content_rect = | |
| 161 occlusion_in_content_space.GetUnoccludedContentRect(content_rect_); | |
| 162 if (visible_content_rect.IsEmpty()) | |
| 163 return; | |
| 164 | |
| 165 SharedQuadState* shared_quad_state = | |
| 166 render_pass->CreateAndAppendSharedQuadState(); | |
| 167 shared_quad_state->SetAll(draw_transform, content_rect_.size(), content_rect_, | |
| 168 clip_rect_, is_clipped_, draw_opacity_, | |
| 169 owning_layer_->blend_mode(), | |
| 170 owning_layer_->sorting_context_id()); | |
| 171 | |
| 172 if (owning_layer_->ShowDebugBorders()) { | |
| 173 DebugBorderDrawQuad* debug_border_quad = | |
| 174 render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>(); | |
| 175 debug_border_quad->SetNew(shared_quad_state, content_rect_, | |
| 176 visible_content_rect, debug_border_color, | |
| 177 debug_border_width); | |
| 178 } | |
| 179 | |
| 180 ResourceProvider::ResourceId mask_resource_id = 0; | |
| 181 gfx::Size mask_texture_size; | |
| 182 gfx::Vector2dF mask_uv_scale; | |
| 183 if (mask_layer && mask_layer->DrawsContent() && | |
| 184 !mask_layer->bounds().IsEmpty()) { | |
| 185 mask_layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size); | |
| 186 gfx::Vector2dF owning_layer_draw_scale = | |
| 187 MathUtil::ComputeTransform2dScaleComponents( | |
| 188 owning_layer_->draw_transform(), 1.f); | |
| 189 gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize( | |
| 190 owning_layer_->content_bounds(), | |
| 191 owning_layer_draw_scale.x(), | |
| 192 owning_layer_draw_scale.y()); | |
| 193 mask_uv_scale = gfx::Vector2dF( | |
| 194 content_rect_.width() / unclipped_mask_target_size.width(), | |
| 195 content_rect_.height() / unclipped_mask_target_size.height()); | |
| 196 } | |
| 197 | |
| 198 DCHECK(owning_layer_->draw_properties().target_space_transform.IsScale2d()); | |
| 199 gfx::Vector2dF owning_layer_to_target_scale = | |
| 200 owning_layer_->draw_properties().target_space_transform.Scale2d(); | |
| 201 owning_layer_to_target_scale.Scale(owning_layer_->contents_scale_x(), | |
| 202 owning_layer_->contents_scale_y()); | |
| 203 | |
| 204 RenderPassDrawQuad* quad = | |
| 205 render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); | |
| 206 quad->SetNew(shared_quad_state, | |
| 207 content_rect_, | |
| 208 visible_content_rect, | |
| 209 render_pass_id, | |
| 210 mask_resource_id, | |
| 211 mask_uv_scale, | |
| 212 mask_texture_size, | |
| 213 owning_layer_->filters(), | |
| 214 owning_layer_to_target_scale, | |
| 215 owning_layer_->background_filters()); | |
| 216 } | |
| 217 | |
| 218 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master