OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/layers/delegated_renderer_layer_impl.h" | 5 #include "cc/layers/delegated_renderer_layer_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 } | 158 } |
159 | 159 |
160 void DelegatedRendererLayerImpl::SetRenderPasses( | 160 void DelegatedRendererLayerImpl::SetRenderPasses( |
161 RenderPassList* render_passes_in_draw_order) { | 161 RenderPassList* render_passes_in_draw_order) { |
162 ClearRenderPasses(); | 162 ClearRenderPasses(); |
163 | 163 |
164 for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) { | 164 for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) { |
165 RenderPassList::iterator to_take = | 165 RenderPassList::iterator to_take = |
166 render_passes_in_draw_order->begin() + i; | 166 render_passes_in_draw_order->begin() + i; |
167 render_passes_index_by_id_.insert( | 167 render_passes_index_by_id_.insert( |
168 std::pair<RenderPass::Id, int>((*to_take)->id, i)); | 168 std::pair<RenderPassId, int>((*to_take)->id, i)); |
169 scoped_ptr<RenderPass> taken_render_pass = | 169 scoped_ptr<RenderPass> taken_render_pass = |
170 render_passes_in_draw_order->take(to_take); | 170 render_passes_in_draw_order->take(to_take); |
171 render_passes_in_draw_order_.push_back(taken_render_pass.Pass()); | 171 render_passes_in_draw_order_.push_back(taken_render_pass.Pass()); |
172 } | 172 } |
173 | 173 |
174 // Give back an empty array instead of nulls. | 174 // Give back an empty array instead of nulls. |
175 render_passes_in_draw_order->clear(); | 175 render_passes_in_draw_order->clear(); |
176 } | 176 } |
177 | 177 |
178 void DelegatedRendererLayerImpl::ClearRenderPasses() { | 178 void DelegatedRendererLayerImpl::ClearRenderPasses() { |
179 render_passes_index_by_id_.clear(); | 179 render_passes_index_by_id_.clear(); |
180 render_passes_in_draw_order_.clear(); | 180 render_passes_in_draw_order_.clear(); |
181 } | 181 } |
182 | 182 |
183 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl( | 183 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl( |
184 LayerTreeImpl* tree_impl) { | 184 LayerTreeImpl* tree_impl) { |
185 return DelegatedRendererLayerImpl::Create( | 185 return DelegatedRendererLayerImpl::Create( |
186 tree_impl, id()).PassAs<LayerImpl>(); | 186 tree_impl, id()).PassAs<LayerImpl>(); |
187 } | 187 } |
188 | 188 |
189 void DelegatedRendererLayerImpl::ReleaseResources() { | 189 void DelegatedRendererLayerImpl::ReleaseResources() { |
190 ClearRenderPasses(); | 190 ClearRenderPasses(); |
191 ClearChildId(); | 191 ClearChildId(); |
192 } | 192 } |
193 | 193 |
194 static inline int IndexToId(int index) { return index + 1; } | 194 static inline int IndexToId(int index) { return index + 1; } |
195 static inline int IdToIndex(int id) { return id - 1; } | 195 static inline int IdToIndex(int id) { return id - 1; } |
196 | 196 |
197 RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId() | 197 RenderPassId DelegatedRendererLayerImpl::FirstContributingRenderPassId() const { |
198 const { | 198 return RenderPassId(id(), IndexToId(0)); |
199 return RenderPass::Id(id(), IndexToId(0)); | |
200 } | 199 } |
201 | 200 |
202 RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId( | 201 RenderPassId DelegatedRendererLayerImpl::NextContributingRenderPassId( |
203 RenderPass::Id previous) const { | 202 RenderPassId previous) const { |
204 return RenderPass::Id(previous.layer_id, previous.index + 1); | 203 return RenderPassId(previous.layer_id, previous.index + 1); |
205 } | 204 } |
206 | 205 |
207 bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId( | 206 bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId( |
208 RenderPass::Id delegated_render_pass_id, | 207 RenderPassId delegated_render_pass_id, |
209 RenderPass::Id* output_render_pass_id) const { | 208 RenderPassId* output_render_pass_id) const { |
210 base::hash_map<RenderPass::Id, int>::const_iterator found = | 209 base::hash_map<RenderPassId, int>::const_iterator found = |
211 render_passes_index_by_id_.find(delegated_render_pass_id); | 210 render_passes_index_by_id_.find(delegated_render_pass_id); |
212 if (found == render_passes_index_by_id_.end()) { | 211 if (found == render_passes_index_by_id_.end()) { |
213 // Be robust against a RenderPass id that isn't part of the frame. | 212 // Be robust against a RenderPass id that isn't part of the frame. |
214 return false; | 213 return false; |
215 } | 214 } |
216 unsigned delegated_render_pass_index = found->second; | 215 unsigned delegated_render_pass_index = found->second; |
217 *output_render_pass_id = | 216 *output_render_pass_id = |
218 RenderPass::Id(id(), IndexToId(delegated_render_pass_index)); | 217 RenderPassId(id(), IndexToId(delegated_render_pass_index)); |
219 return true; | 218 return true; |
220 } | 219 } |
221 | 220 |
222 void DelegatedRendererLayerImpl::AppendContributingRenderPasses( | 221 void DelegatedRendererLayerImpl::AppendContributingRenderPasses( |
223 RenderPassSink* render_pass_sink) { | 222 RenderPassSink* render_pass_sink) { |
224 DCHECK(HasContributingDelegatedRenderPasses()); | 223 DCHECK(HasContributingDelegatedRenderPasses()); |
225 | 224 |
226 const RenderPass* root_delegated_render_pass = | 225 const RenderPass* root_delegated_render_pass = |
227 render_passes_in_draw_order_.back(); | 226 render_passes_in_draw_order_.back(); |
228 gfx::Size frame_size = root_delegated_render_pass->output_rect.size(); | 227 gfx::Size frame_size = root_delegated_render_pass->output_rect.size(); |
229 gfx::Transform delegated_frame_to_root_transform = screen_space_transform(); | 228 gfx::Transform delegated_frame_to_root_transform = screen_space_transform(); |
230 delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_, | 229 delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_, |
231 inverse_device_scale_factor_); | 230 inverse_device_scale_factor_); |
232 | 231 |
233 for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) { | 232 for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) { |
234 RenderPass::Id output_render_pass_id(-1, -1); | 233 RenderPassId output_render_pass_id(-1, -1); |
235 bool present = | 234 bool present = |
236 ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id, | 235 ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id, |
237 &output_render_pass_id); | 236 &output_render_pass_id); |
238 | 237 |
239 // Don't clash with the RenderPass we generate if we own a RenderSurface. | 238 // Don't clash with the RenderPass we generate if we own a RenderSurface. |
240 DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", " | 239 DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", " |
241 << render_passes_in_draw_order_[i]->id.index; | 240 << render_passes_in_draw_order_[i]->id.index; |
242 DCHECK_GT(output_render_pass_id.index, 0); | 241 DCHECK_GT(output_render_pass_id.index, 0); |
243 | 242 |
244 scoped_ptr<RenderPass> copy_pass = | 243 scoped_ptr<RenderPass> copy_pass = |
(...skipping 14 matching lines...) Expand all Loading... |
259 void DelegatedRendererLayerImpl::AppendQuads( | 258 void DelegatedRendererLayerImpl::AppendQuads( |
260 RenderPass* render_pass, | 259 RenderPass* render_pass, |
261 const OcclusionTracker<LayerImpl>& occlusion_tracker, | 260 const OcclusionTracker<LayerImpl>& occlusion_tracker, |
262 AppendQuadsData* append_quads_data) { | 261 AppendQuadsData* append_quads_data) { |
263 AppendRainbowDebugBorder(render_pass, append_quads_data); | 262 AppendRainbowDebugBorder(render_pass, append_quads_data); |
264 | 263 |
265 // This list will be empty after a lost context until a new frame arrives. | 264 // This list will be empty after a lost context until a new frame arrives. |
266 if (render_passes_in_draw_order_.empty()) | 265 if (render_passes_in_draw_order_.empty()) |
267 return; | 266 return; |
268 | 267 |
269 RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id; | 268 RenderPassId target_render_pass_id = append_quads_data->render_pass_id; |
270 | 269 |
271 const RenderPass* root_delegated_render_pass = | 270 const RenderPass* root_delegated_render_pass = |
272 render_passes_in_draw_order_.back(); | 271 render_passes_in_draw_order_.back(); |
273 | 272 |
274 DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin()); | 273 DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin()); |
275 gfx::Size frame_size = root_delegated_render_pass->output_rect.size(); | 274 gfx::Size frame_size = root_delegated_render_pass->output_rect.size(); |
276 | 275 |
277 // If the index of the RenderPassId is 0, then it is a RenderPass generated | 276 // If the index of the RenderPassId is 0, then it is a RenderPass generated |
278 // for a layer in this compositor, not the delegating renderer. Then we want | 277 // for a layer in this compositor, not the delegating renderer. Then we want |
279 // to merge our root RenderPass with the target RenderPass. Otherwise, it is | 278 // to merge our root RenderPass with the target RenderPass. Otherwise, it is |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
449 delegated_quad->visible_rect, quad_content_to_delegated_target_space); | 448 delegated_quad->visible_rect, quad_content_to_delegated_target_space); |
450 | 449 |
451 if (quad_visible_rect.IsEmpty()) | 450 if (quad_visible_rect.IsEmpty()) |
452 continue; | 451 continue; |
453 | 452 |
454 if (delegated_quad->material != DrawQuad::RENDER_PASS) { | 453 if (delegated_quad->material != DrawQuad::RENDER_PASS) { |
455 DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad( | 454 DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad( |
456 delegated_quad, output_shared_quad_state); | 455 delegated_quad, output_shared_quad_state); |
457 output_quad->visible_rect = quad_visible_rect; | 456 output_quad->visible_rect = quad_visible_rect; |
458 } else { | 457 } else { |
459 RenderPass::Id delegated_contributing_render_pass_id = | 458 RenderPassId delegated_contributing_render_pass_id = |
460 RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id; | 459 RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id; |
461 RenderPass::Id output_contributing_render_pass_id(-1, -1); | 460 RenderPassId output_contributing_render_pass_id(-1, -1); |
462 | 461 |
463 bool present = | 462 bool present = |
464 ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id, | 463 ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id, |
465 &output_contributing_render_pass_id); | 464 &output_contributing_render_pass_id); |
466 | 465 |
467 // The frame may have a RenderPassDrawQuad that points to a RenderPass not | 466 // The frame may have a RenderPassDrawQuad that points to a RenderPass not |
468 // part of the frame. Just ignore these quads. | 467 // part of the frame. Just ignore these quads. |
469 if (present) { | 468 if (present) { |
470 DCHECK(output_contributing_render_pass_id != | 469 DCHECK(output_contributing_render_pass_id != |
471 append_quads_data->render_pass_id); | 470 append_quads_data->render_pass_id); |
(...skipping 20 matching lines...) Expand all Loading... |
492 if (own_child_id_) { | 491 if (own_child_id_) { |
493 ResourceProvider* provider = layer_tree_impl()->resource_provider(); | 492 ResourceProvider* provider = layer_tree_impl()->resource_provider(); |
494 provider->DestroyChild(child_id_); | 493 provider->DestroyChild(child_id_); |
495 } | 494 } |
496 | 495 |
497 resources_.clear(); | 496 resources_.clear(); |
498 child_id_ = 0; | 497 child_id_ = 0; |
499 } | 498 } |
500 | 499 |
501 } // namespace cc | 500 } // namespace cc |
OLD | NEW |