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/output/direct_renderer.h"
6
7 #include <utility>
8 #include <vector>
9
10 #include "base/containers/hash_tables.h"
11 #include "base/containers/scoped_ptr_hash_map.h"
12 #include "base/debug/trace_event.h"
13 #include "base/metrics/histogram.h"
14 #include "cc/base/math_util.h"
15 #include "cc/output/copy_output_request.h"
16 #include "cc/quads/draw_quad.h"
17 #include "ui/gfx/rect_conversions.h"
18 #include "ui/gfx/transform.h"
19
OrthoProjectionMatrix(float left,float right,float bottom,float top)20 static gfx::Transform OrthoProjectionMatrix(float left,
21 float right,
22 float bottom,
23 float top) {
24 // Use the standard formula to map the clipping frustum to the cube from
25 // [-1, -1, -1] to [1, 1, 1].
26 float delta_x = right - left;
27 float delta_y = top - bottom;
28 gfx::Transform proj;
29 if (!delta_x || !delta_y)
30 return proj;
31 proj.matrix().set(0, 0, 2.0f / delta_x);
32 proj.matrix().set(0, 3, -(right + left) / delta_x);
33 proj.matrix().set(1, 1, 2.0f / delta_y);
34 proj.matrix().set(1, 3, -(top + bottom) / delta_y);
35
36 // Z component of vertices is always set to zero as we don't use the depth
37 // buffer while drawing.
38 proj.matrix().set(2, 2, 0);
39
40 return proj;
41 }
42
window_matrix(int x,int y,int width,int height)43 static gfx::Transform window_matrix(int x, int y, int width, int height) {
44 gfx::Transform canvas;
45
46 // Map to window position and scale up to pixel coordinates.
47 canvas.Translate3d(x, y, 0);
48 canvas.Scale3d(width, height, 0);
49
50 // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
51 canvas.Translate3d(0.5, 0.5, 0.5);
52 canvas.Scale3d(0.5, 0.5, 0.5);
53
54 return canvas;
55 }
56
57 namespace cc {
58
DrawingFrame()59 DirectRenderer::DrawingFrame::DrawingFrame()
60 : root_render_pass(NULL),
61 current_render_pass(NULL),
62 current_texture(NULL),
63 offscreen_context_provider(NULL) {}
64
~DrawingFrame()65 DirectRenderer::DrawingFrame::~DrawingFrame() {}
66
67 //
68 // static
QuadVertexRect()69 gfx::RectF DirectRenderer::QuadVertexRect() {
70 return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
71 }
72
73 // static
QuadRectTransform(gfx::Transform * quad_rect_transform,const gfx::Transform & quad_transform,const gfx::RectF & quad_rect)74 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
75 const gfx::Transform& quad_transform,
76 const gfx::RectF& quad_rect) {
77 *quad_rect_transform = quad_transform;
78 quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
79 0.5 * quad_rect.height() + quad_rect.y());
80 quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
81 }
82
InitializeViewport(DrawingFrame * frame,gfx::Rect draw_rect,gfx::Rect viewport_rect,gfx::Size surface_size)83 void DirectRenderer::InitializeViewport(DrawingFrame* frame,
84 gfx::Rect draw_rect,
85 gfx::Rect viewport_rect,
86 gfx::Size surface_size) {
87 bool flip_y = FlippedFramebuffer();
88
89 DCHECK_GE(viewport_rect.x(), 0);
90 DCHECK_GE(viewport_rect.y(), 0);
91 DCHECK_LE(viewport_rect.right(), surface_size.width());
92 DCHECK_LE(viewport_rect.bottom(), surface_size.height());
93 if (flip_y) {
94 frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
95 draw_rect.right(),
96 draw_rect.bottom(),
97 draw_rect.y());
98 } else {
99 frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
100 draw_rect.right(),
101 draw_rect.y(),
102 draw_rect.bottom());
103 }
104
105 gfx::Rect window_rect = viewport_rect;
106 if (flip_y)
107 window_rect.set_y(surface_size.height() - viewport_rect.bottom());
108 frame->window_matrix = window_matrix(window_rect.x(),
109 window_rect.y(),
110 window_rect.width(),
111 window_rect.height());
112 SetDrawViewport(window_rect);
113
114 current_draw_rect_ = draw_rect;
115 current_viewport_rect_ = viewport_rect;
116 current_surface_size_ = surface_size;
117 }
118
MoveFromDrawToWindowSpace(const gfx::RectF & draw_rect) const119 gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
120 const gfx::RectF& draw_rect) const {
121 gfx::Rect window_rect = gfx::ToEnclosingRect(draw_rect);
122 window_rect -= current_draw_rect_.OffsetFromOrigin();
123 window_rect += current_viewport_rect_.OffsetFromOrigin();
124 if (FlippedFramebuffer())
125 window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
126 return window_rect;
127 }
128
DirectRenderer(RendererClient * client,const LayerTreeSettings * settings,OutputSurface * output_surface,ResourceProvider * resource_provider)129 DirectRenderer::DirectRenderer(RendererClient* client,
130 const LayerTreeSettings* settings,
131 OutputSurface* output_surface,
132 ResourceProvider* resource_provider)
133 : Renderer(client, settings),
134 output_surface_(output_surface),
135 resource_provider_(resource_provider) {}
136
~DirectRenderer()137 DirectRenderer::~DirectRenderer() {}
138
CanReadPixels() const139 bool DirectRenderer::CanReadPixels() const { return true; }
140
SetEnlargePassTextureAmountForTesting(gfx::Vector2d amount)141 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
142 gfx::Vector2d amount) {
143 enlarge_pass_texture_amount_ = amount;
144 }
145
DecideRenderPassAllocationsForFrame(const RenderPassList & render_passes_in_draw_order)146 void DirectRenderer::DecideRenderPassAllocationsForFrame(
147 const RenderPassList& render_passes_in_draw_order) {
148 if (!resource_provider_)
149 return;
150
151 base::hash_map<RenderPass::Id, gfx::Size> render_passes_in_frame;
152 for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
153 render_passes_in_frame.insert(std::pair<RenderPass::Id, gfx::Size>(
154 render_passes_in_draw_order[i]->id,
155 RenderPassTextureSize(render_passes_in_draw_order[i])));
156
157 std::vector<RenderPass::Id> passes_to_delete;
158 base::ScopedPtrHashMap<RenderPass::Id, ScopedResource>::const_iterator
159 pass_iter;
160 for (pass_iter = render_pass_textures_.begin();
161 pass_iter != render_pass_textures_.end();
162 ++pass_iter) {
163 base::hash_map<RenderPass::Id, gfx::Size>::const_iterator it =
164 render_passes_in_frame.find(pass_iter->first);
165 if (it == render_passes_in_frame.end()) {
166 passes_to_delete.push_back(pass_iter->first);
167 continue;
168 }
169
170 gfx::Size required_size = it->second;
171 ScopedResource* texture = pass_iter->second;
172 DCHECK(texture);
173
174 bool size_appropriate = texture->size().width() >= required_size.width() &&
175 texture->size().height() >= required_size.height();
176 if (texture->id() && !size_appropriate)
177 texture->Free();
178 }
179
180 // Delete RenderPass textures from the previous frame that will not be used
181 // again.
182 for (size_t i = 0; i < passes_to_delete.size(); ++i)
183 render_pass_textures_.erase(passes_to_delete[i]);
184
185 for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
186 if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
187 scoped_ptr<ScopedResource> texture =
188 ScopedResource::Create(resource_provider_);
189 render_pass_textures_.set(render_passes_in_draw_order[i]->id,
190 texture.Pass());
191 }
192 }
193 }
194
DrawFrame(RenderPassList * render_passes_in_draw_order,ContextProvider * offscreen_context_provider,float device_scale_factor,gfx::Rect device_viewport_rect,gfx::Rect device_clip_rect,bool allow_partial_swap,bool disable_picture_quad_image_filtering)195 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
196 ContextProvider* offscreen_context_provider,
197 float device_scale_factor,
198 gfx::Rect device_viewport_rect,
199 gfx::Rect device_clip_rect,
200 bool allow_partial_swap,
201 bool disable_picture_quad_image_filtering) {
202 TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
203 UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
204 render_passes_in_draw_order->size());
205
206 const RenderPass* root_render_pass = render_passes_in_draw_order->back();
207 DCHECK(root_render_pass);
208
209 DrawingFrame frame;
210 frame.root_render_pass = root_render_pass;
211 frame.root_damage_rect =
212 Capabilities().using_partial_swap && allow_partial_swap
213 ? root_render_pass->damage_rect
214 : root_render_pass->output_rect;
215 frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_rect.size()));
216 frame.device_viewport_rect = device_viewport_rect;
217 frame.device_clip_rect = device_clip_rect;
218 frame.offscreen_context_provider = offscreen_context_provider;
219 frame.disable_picture_quad_image_filtering =
220 disable_picture_quad_image_filtering;
221
222 EnsureBackbuffer();
223
224 // Only reshape when we know we are going to draw. Otherwise, the reshape
225 // can leave the window at the wrong size if we never draw and the proper
226 // viewport size is never set.
227 output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor);
228
229 BeginDrawingFrame(&frame);
230 for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
231 RenderPass* pass = render_passes_in_draw_order->at(i);
232 DrawRenderPass(&frame, pass, allow_partial_swap);
233
234 for (ScopedPtrVector<CopyOutputRequest>::iterator it =
235 pass->copy_requests.begin();
236 it != pass->copy_requests.end();
237 ++it) {
238 if (i > 0) {
239 // Doing a readback is destructive of our state on Mac, so make sure
240 // we restore the state between readbacks. http://crbug.com/99393.
241 UseRenderPass(&frame, pass);
242 }
243 CopyCurrentRenderPassToBitmap(&frame, pass->copy_requests.take(it));
244 }
245 }
246 FinishDrawingFrame(&frame);
247
248 render_passes_in_draw_order->clear();
249 }
250
ComputeScissorRectForRenderPass(const DrawingFrame * frame)251 gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
252 const DrawingFrame* frame) {
253 gfx::RectF render_pass_scissor = frame->current_render_pass->output_rect;
254
255 if (frame->root_damage_rect == frame->root_render_pass->output_rect)
256 return render_pass_scissor;
257
258 gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
259 if (frame->current_render_pass->transform_to_root_target.GetInverse(
260 &inverse_transform)) {
261 // Only intersect inverse-projected damage if the transform is invertible.
262 gfx::RectF damage_rect_in_render_pass_space =
263 MathUtil::ProjectClippedRect(inverse_transform,
264 frame->root_damage_rect);
265 render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
266 }
267
268 return render_pass_scissor;
269 }
270
NeedDeviceClip(const DrawingFrame * frame) const271 bool DirectRenderer::NeedDeviceClip(const DrawingFrame* frame) const {
272 if (frame->current_render_pass != frame->root_render_pass)
273 return false;
274
275 return !frame->device_clip_rect.Contains(frame->device_viewport_rect);
276 }
277
DeviceClipRectInWindowSpace(const DrawingFrame * frame) const278 gfx::Rect DirectRenderer::DeviceClipRectInWindowSpace(const DrawingFrame* frame)
279 const {
280 gfx::Rect device_clip_rect = frame->device_clip_rect;
281 if (FlippedFramebuffer())
282 device_clip_rect.set_y(current_surface_size_.height() -
283 device_clip_rect.bottom());
284 return device_clip_rect;
285 }
286
SetScissorStateForQuad(const DrawingFrame * frame,const DrawQuad & quad)287 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
288 const DrawQuad& quad) {
289 if (quad.isClipped()) {
290 SetScissorTestRectInDrawSpace(frame, quad.clipRect());
291 return;
292 }
293 if (NeedDeviceClip(frame)) {
294 SetScissorTestRect(DeviceClipRectInWindowSpace(frame));
295 return;
296 }
297
298 EnsureScissorTestDisabled();
299 }
300
SetScissorStateForQuadWithRenderPassScissor(const DrawingFrame * frame,const DrawQuad & quad,const gfx::RectF & render_pass_scissor,bool * should_skip_quad)301 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
302 const DrawingFrame* frame,
303 const DrawQuad& quad,
304 const gfx::RectF& render_pass_scissor,
305 bool* should_skip_quad) {
306 gfx::RectF quad_scissor_rect = render_pass_scissor;
307
308 if (quad.isClipped())
309 quad_scissor_rect.Intersect(quad.clipRect());
310
311 if (quad_scissor_rect.IsEmpty()) {
312 *should_skip_quad = true;
313 return;
314 }
315
316 *should_skip_quad = false;
317 SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
318 }
319
SetScissorTestRectInDrawSpace(const DrawingFrame * frame,gfx::RectF draw_space_rect)320 void DirectRenderer::SetScissorTestRectInDrawSpace(const DrawingFrame* frame,
321 gfx::RectF draw_space_rect) {
322 gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
323 if (NeedDeviceClip(frame))
324 window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
325 SetScissorTestRect(window_space_rect);
326 }
327
FinishDrawingQuadList()328 void DirectRenderer::FinishDrawingQuadList() {}
329
DrawRenderPass(DrawingFrame * frame,const RenderPass * render_pass,bool allow_partial_swap)330 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
331 const RenderPass* render_pass,
332 bool allow_partial_swap) {
333 TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
334 if (!UseRenderPass(frame, render_pass))
335 return;
336
337 bool using_scissor_as_optimization =
338 Capabilities().using_partial_swap && allow_partial_swap;
339 gfx::RectF render_pass_scissor;
340 bool draw_rect_covers_full_surface = true;
341 if (frame->current_render_pass == frame->root_render_pass &&
342 !frame->device_viewport_rect.Contains(
343 gfx::Rect(output_surface_->SurfaceSize())))
344 draw_rect_covers_full_surface = false;
345
346 if (using_scissor_as_optimization) {
347 render_pass_scissor = ComputeScissorRectForRenderPass(frame);
348 SetScissorTestRectInDrawSpace(frame, render_pass_scissor);
349 if (!render_pass_scissor.Contains(frame->current_render_pass->output_rect))
350 draw_rect_covers_full_surface = false;
351 }
352
353 if (frame->current_render_pass != frame->root_render_pass ||
354 settings_->should_clear_root_render_pass) {
355 if (NeedDeviceClip(frame)) {
356 SetScissorTestRect(DeviceClipRectInWindowSpace(frame));
357 draw_rect_covers_full_surface = false;
358 } else if (!using_scissor_as_optimization) {
359 EnsureScissorTestDisabled();
360 }
361
362 bool has_external_stencil_test =
363 output_surface_->HasExternalStencilTest() &&
364 frame->current_render_pass == frame->root_render_pass;
365
366 DiscardPixels(has_external_stencil_test, draw_rect_covers_full_surface);
367 ClearFramebuffer(frame, has_external_stencil_test);
368 }
369
370 const QuadList& quad_list = render_pass->quad_list;
371 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
372 it != quad_list.BackToFrontEnd();
373 ++it) {
374 const DrawQuad& quad = *(*it);
375 bool should_skip_quad = false;
376
377 if (using_scissor_as_optimization) {
378 SetScissorStateForQuadWithRenderPassScissor(
379 frame, quad, render_pass_scissor, &should_skip_quad);
380 } else {
381 SetScissorStateForQuad(frame, quad);
382 }
383
384 if (!should_skip_quad)
385 DoDrawQuad(frame, *it);
386 }
387 FinishDrawingQuadList();
388 }
389
UseRenderPass(DrawingFrame * frame,const RenderPass * render_pass)390 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
391 const RenderPass* render_pass) {
392 frame->current_render_pass = render_pass;
393 frame->current_texture = NULL;
394
395 if (render_pass == frame->root_render_pass) {
396 BindFramebufferToOutputSurface(frame);
397 InitializeViewport(frame,
398 render_pass->output_rect,
399 frame->device_viewport_rect,
400 output_surface_->SurfaceSize());
401 return true;
402 }
403
404 ScopedResource* texture = render_pass_textures_.get(render_pass->id);
405 DCHECK(texture);
406
407 gfx::Size size = RenderPassTextureSize(render_pass);
408 size.Enlarge(enlarge_pass_texture_amount_.x(),
409 enlarge_pass_texture_amount_.y());
410 if (!texture->id())
411 texture->Allocate(
412 size, ResourceProvider::TextureUsageFramebuffer, RGBA_8888);
413 DCHECK(texture->id());
414
415 return BindFramebufferToTexture(frame, texture, render_pass->output_rect);
416 }
417
HasAllocatedResourcesForTesting(RenderPass::Id id) const418 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPass::Id id)
419 const {
420 ScopedResource* texture = render_pass_textures_.get(id);
421 return texture && texture->id();
422 }
423
424 // static
RenderPassTextureSize(const RenderPass * render_pass)425 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
426 return render_pass->output_rect.size();
427 }
428
429 } // namespace cc
430