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/quads/render_pass.h"
6
7 #include "base/values.h"
8 #include "cc/base/math_util.h"
9 #include "cc/debug/traced_value.h"
10 #include "cc/output/copy_output_request.h"
11 #include "cc/quads/draw_quad.h"
12 #include "cc/quads/render_pass_draw_quad.h"
13 #include "cc/quads/shared_quad_state.h"
14
15 namespace {
16 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
17 const size_t kDefaultNumQuadsToReserve = 128;
18 }
19
20 namespace cc {
21
AsTracingId() const22 void* RenderPass::Id::AsTracingId() const {
23 COMPILE_ASSERT(sizeof(size_t) <= sizeof(void*), // NOLINT
24 size_t_bigger_than_pointer);
25 return reinterpret_cast<void*>(base::HashPair(layer_id, index));
26 }
27
Create()28 scoped_ptr<RenderPass> RenderPass::Create() {
29 return make_scoped_ptr(new RenderPass());
30 }
31
Create(size_t num_layers)32 scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
33 return make_scoped_ptr(new RenderPass(num_layers));
34 }
35
RenderPass()36 RenderPass::RenderPass() : id(Id(-1, -1)), has_transparent_background(true) {
37 shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
38 quad_list.reserve(kDefaultNumQuadsToReserve);
39 }
40
RenderPass(size_t num_layers)41 RenderPass::RenderPass(size_t num_layers)
42 : id(Id(-1, -1)), has_transparent_background(true) {
43 // Each layer usually produces one shared quad state, so the number of layers
44 // is a good hint for what to reserve here.
45 shared_quad_state_list.reserve(num_layers);
46 quad_list.reserve(kDefaultNumQuadsToReserve);
47 }
48
~RenderPass()49 RenderPass::~RenderPass() {
50 TRACE_EVENT_OBJECT_DELETED_WITH_ID(
51 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
52 "cc::RenderPass", id.AsTracingId());
53 }
54
Copy(Id new_id) const55 scoped_ptr<RenderPass> RenderPass::Copy(Id new_id) const {
56 scoped_ptr<RenderPass> copy_pass(Create());
57 copy_pass->SetAll(new_id,
58 output_rect,
59 damage_rect,
60 transform_to_root_target,
61 has_transparent_background);
62 return copy_pass.Pass();
63 }
64
65 // static
CopyAll(const ScopedPtrVector<RenderPass> & in,ScopedPtrVector<RenderPass> * out)66 void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
67 ScopedPtrVector<RenderPass>* out) {
68 for (size_t i = 0; i < in.size(); ++i) {
69 RenderPass* source = in[i];
70
71 // Since we can't copy these, it's wrong to use CopyAll in a situation where
72 // you may have copy_requests present.
73 DCHECK_EQ(source->copy_requests.size(), 0u);
74
75 scoped_ptr<RenderPass> copy_pass(Create());
76 copy_pass->SetAll(source->id,
77 source->output_rect,
78 source->damage_rect,
79 source->transform_to_root_target,
80 source->has_transparent_background);
81 for (size_t i = 0; i < source->shared_quad_state_list.size(); ++i) {
82 SharedQuadState* copy_shared_quad_state =
83 copy_pass->CreateAndAppendSharedQuadState();
84 copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
85 }
86 for (size_t i = 0, sqs_i = 0; i < source->quad_list.size(); ++i) {
87 while (source->quad_list[i]->shared_quad_state !=
88 source->shared_quad_state_list[sqs_i]) {
89 ++sqs_i;
90 DCHECK_LT(sqs_i, source->shared_quad_state_list.size());
91 }
92 DCHECK(source->quad_list[i]->shared_quad_state ==
93 source->shared_quad_state_list[sqs_i]);
94
95 DrawQuad* quad = source->quad_list[i];
96
97 if (quad->material == DrawQuad::RENDER_PASS) {
98 const RenderPassDrawQuad* pass_quad =
99 RenderPassDrawQuad::MaterialCast(quad);
100 copy_pass->quad_list.push_back(
101 pass_quad->Copy(copy_pass->shared_quad_state_list[sqs_i],
102 pass_quad->render_pass_id).PassAs<DrawQuad>());
103 } else {
104 copy_pass->quad_list.push_back(source->quad_list[i]->Copy(
105 copy_pass->shared_quad_state_list[sqs_i]));
106 }
107 }
108 out->push_back(copy_pass.Pass());
109 }
110 }
111
SetNew(Id id,const gfx::Rect & output_rect,const gfx::Rect & damage_rect,const gfx::Transform & transform_to_root_target)112 void RenderPass::SetNew(Id id,
113 const gfx::Rect& output_rect,
114 const gfx::Rect& damage_rect,
115 const gfx::Transform& transform_to_root_target) {
116 DCHECK_GT(id.layer_id, 0);
117 DCHECK_GE(id.index, 0);
118 DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
119 << "damage_rect: " << damage_rect.ToString()
120 << " output_rect: " << output_rect.ToString();
121
122 this->id = id;
123 this->output_rect = output_rect;
124 this->damage_rect = damage_rect;
125 this->transform_to_root_target = transform_to_root_target;
126
127 DCHECK(quad_list.empty());
128 DCHECK(shared_quad_state_list.empty());
129 }
130
SetAll(Id id,const gfx::Rect & output_rect,const gfx::Rect & damage_rect,const gfx::Transform & transform_to_root_target,bool has_transparent_background)131 void RenderPass::SetAll(Id id,
132 const gfx::Rect& output_rect,
133 const gfx::Rect& damage_rect,
134 const gfx::Transform& transform_to_root_target,
135 bool has_transparent_background) {
136 DCHECK_GT(id.layer_id, 0);
137 DCHECK_GE(id.index, 0);
138
139 this->id = id;
140 this->output_rect = output_rect;
141 this->damage_rect = damage_rect;
142 this->transform_to_root_target = transform_to_root_target;
143 this->has_transparent_background = has_transparent_background;
144
145 DCHECK(quad_list.empty());
146 DCHECK(shared_quad_state_list.empty());
147 }
148
AsValue() const149 scoped_ptr<base::Value> RenderPass::AsValue() const {
150 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
151 value->Set("output_rect", MathUtil::AsValue(output_rect).release());
152 value->Set("damage_rect", MathUtil::AsValue(damage_rect).release());
153 value->SetBoolean("has_transparent_background", has_transparent_background);
154 value->SetInteger("copy_requests", copy_requests.size());
155 scoped_ptr<base::ListValue> shared_states_value(new base::ListValue());
156 for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
157 shared_states_value->Append(shared_quad_state_list[i]->AsValue().release());
158 }
159 value->Set("shared_quad_state_list", shared_states_value.release());
160 scoped_ptr<base::ListValue> quad_list_value(new base::ListValue());
161 for (size_t i = 0; i < quad_list.size(); ++i) {
162 quad_list_value->Append(quad_list[i]->AsValue().release());
163 }
164 value->Set("quad_list", quad_list_value.release());
165
166 TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
167 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
168 value.get(), "cc::RenderPass", id.AsTracingId());
169 return value.PassAs<base::Value>();
170 }
171
CreateAndAppendSharedQuadState()172 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
173 shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
174 return shared_quad_state_list.back();
175 }
176
AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad)177 void RenderPass::AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad) {
178 quad_list.push_back(draw_quad.Pass());
179 }
180
181 } // namespace cc
182