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.
5 #include "cc/output/direct_renderer.h"
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 "cc/resources/raster_worker_pool.h"
18 #include "ui/gfx/rect_conversions.h"
19 #include "ui/gfx/transform.h"
21 static gfx::Transform
OrthoProjectionMatrix(float left
,
25 // Use the standard formula to map the clipping frustum to the cube from
26 // [-1, -1, -1] to [1, 1, 1].
27 float delta_x
= right
- left
;
28 float delta_y
= top
- bottom
;
30 if (!delta_x
|| !delta_y
)
32 proj
.matrix().set(0, 0, 2.0f
/ delta_x
);
33 proj
.matrix().set(0, 3, -(right
+ left
) / delta_x
);
34 proj
.matrix().set(1, 1, 2.0f
/ delta_y
);
35 proj
.matrix().set(1, 3, -(top
+ bottom
) / delta_y
);
37 // Z component of vertices is always set to zero as we don't use the depth
38 // buffer while drawing.
39 proj
.matrix().set(2, 2, 0);
44 static gfx::Transform
window_matrix(int x
, int y
, int width
, int height
) {
45 gfx::Transform canvas
;
47 // Map to window position and scale up to pixel coordinates.
48 canvas
.Translate3d(x
, y
, 0);
49 canvas
.Scale3d(width
, height
, 0);
51 // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
52 canvas
.Translate3d(0.5, 0.5, 0.5);
53 canvas
.Scale3d(0.5, 0.5, 0.5);
60 DirectRenderer::DrawingFrame::DrawingFrame()
61 : root_render_pass(NULL
), current_render_pass(NULL
), current_texture(NULL
) {
64 DirectRenderer::DrawingFrame::~DrawingFrame() {}
68 gfx::RectF
DirectRenderer::QuadVertexRect() {
69 return gfx::RectF(-0.5f
, -0.5f
, 1.f
, 1.f
);
73 void DirectRenderer::QuadRectTransform(gfx::Transform
* quad_rect_transform
,
74 const gfx::Transform
& quad_transform
,
75 const gfx::RectF
& quad_rect
) {
76 *quad_rect_transform
= quad_transform
;
77 quad_rect_transform
->Translate(0.5 * quad_rect
.width() + quad_rect
.x(),
78 0.5 * quad_rect
.height() + quad_rect
.y());
79 quad_rect_transform
->Scale(quad_rect
.width(), quad_rect
.height());
82 void DirectRenderer::InitializeViewport(DrawingFrame
* frame
,
83 const gfx::Rect
& draw_rect
,
84 const gfx::Rect
& viewport_rect
,
85 const gfx::Size
& surface_size
) {
86 bool flip_y
= FlippedFramebuffer();
88 DCHECK_GE(viewport_rect
.x(), 0);
89 DCHECK_GE(viewport_rect
.y(), 0);
90 DCHECK_LE(viewport_rect
.right(), surface_size
.width());
91 DCHECK_LE(viewport_rect
.bottom(), surface_size
.height());
93 frame
->projection_matrix
= OrthoProjectionMatrix(draw_rect
.x(),
98 frame
->projection_matrix
= OrthoProjectionMatrix(draw_rect
.x(),
104 gfx::Rect window_rect
= viewport_rect
;
106 window_rect
.set_y(surface_size
.height() - viewport_rect
.bottom());
107 frame
->window_matrix
= window_matrix(window_rect
.x(),
110 window_rect
.height());
111 SetDrawViewport(window_rect
);
113 current_draw_rect_
= draw_rect
;
114 current_viewport_rect_
= viewport_rect
;
115 current_surface_size_
= surface_size
;
118 gfx::Rect
DirectRenderer::MoveFromDrawToWindowSpace(
119 const gfx::Rect
& draw_rect
) const {
120 gfx::Rect window_rect
= draw_rect
;
121 window_rect
-= current_draw_rect_
.OffsetFromOrigin();
122 window_rect
+= current_viewport_rect_
.OffsetFromOrigin();
123 if (FlippedFramebuffer())
124 window_rect
.set_y(current_surface_size_
.height() - window_rect
.bottom());
128 DirectRenderer::DirectRenderer(RendererClient
* client
,
129 const LayerTreeSettings
* settings
,
130 OutputSurface
* output_surface
,
131 ResourceProvider
* resource_provider
)
132 : Renderer(client
, settings
),
133 output_surface_(output_surface
),
134 resource_provider_(resource_provider
),
136 new OverlayProcessor(output_surface
, resource_provider
)) {
137 overlay_processor_
->Initialize();
140 DirectRenderer::~DirectRenderer() {}
142 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
143 const gfx::Vector2d
& amount
) {
144 enlarge_pass_texture_amount_
= amount
;
147 void DirectRenderer::DecideRenderPassAllocationsForFrame(
148 const RenderPassList
& render_passes_in_draw_order
) {
149 if (!resource_provider_
)
152 base::hash_map
<RenderPass::Id
, gfx::Size
> render_passes_in_frame
;
153 for (size_t i
= 0; i
< render_passes_in_draw_order
.size(); ++i
)
154 render_passes_in_frame
.insert(std::pair
<RenderPass::Id
, gfx::Size
>(
155 render_passes_in_draw_order
[i
]->id
,
156 RenderPassTextureSize(render_passes_in_draw_order
[i
])));
158 std::vector
<RenderPass::Id
> passes_to_delete
;
159 base::ScopedPtrHashMap
<RenderPass::Id
, ScopedResource
>::const_iterator
161 for (pass_iter
= render_pass_textures_
.begin();
162 pass_iter
!= render_pass_textures_
.end();
164 base::hash_map
<RenderPass::Id
, gfx::Size
>::const_iterator it
=
165 render_passes_in_frame
.find(pass_iter
->first
);
166 if (it
== render_passes_in_frame
.end()) {
167 passes_to_delete
.push_back(pass_iter
->first
);
171 gfx::Size required_size
= it
->second
;
172 ScopedResource
* texture
= pass_iter
->second
;
175 bool size_appropriate
= texture
->size().width() >= required_size
.width() &&
176 texture
->size().height() >= required_size
.height();
177 if (texture
->id() && !size_appropriate
)
181 // Delete RenderPass textures from the previous frame that will not be used
183 for (size_t i
= 0; i
< passes_to_delete
.size(); ++i
)
184 render_pass_textures_
.erase(passes_to_delete
[i
]);
186 for (size_t i
= 0; i
< render_passes_in_draw_order
.size(); ++i
) {
187 if (!render_pass_textures_
.contains(render_passes_in_draw_order
[i
]->id
)) {
188 scoped_ptr
<ScopedResource
> texture
=
189 ScopedResource::Create(resource_provider_
);
190 render_pass_textures_
.set(render_passes_in_draw_order
[i
]->id
,
196 void DirectRenderer::DrawFrame(RenderPassList
* render_passes_in_draw_order
,
197 float device_scale_factor
,
198 const gfx::Rect
& device_viewport_rect
,
199 const gfx::Rect
& device_clip_rect
,
200 bool disable_picture_quad_image_filtering
) {
201 TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
202 UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
203 render_passes_in_draw_order
->size());
205 const RenderPass
* root_render_pass
= render_passes_in_draw_order
->back();
206 DCHECK(root_render_pass
);
209 frame
.root_render_pass
= root_render_pass
;
210 frame
.root_damage_rect
= Capabilities().using_partial_swap
211 ? root_render_pass
->damage_rect
212 : root_render_pass
->output_rect
;
213 frame
.root_damage_rect
.Intersect(gfx::Rect(device_viewport_rect
.size()));
214 frame
.device_viewport_rect
= device_viewport_rect
;
215 frame
.device_clip_rect
= device_clip_rect
;
216 frame
.disable_picture_quad_image_filtering
=
217 disable_picture_quad_image_filtering
;
219 overlay_processor_
->ProcessForOverlays(render_passes_in_draw_order
,
220 &frame
.overlay_list
);
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
);
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
);
234 for (ScopedPtrVector
<CopyOutputRequest
>::iterator it
=
235 pass
->copy_requests
.begin();
236 it
!= pass
->copy_requests
.end();
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
);
243 CopyCurrentRenderPassToBitmap(&frame
, pass
->copy_requests
.take(it
));
246 FinishDrawingFrame(&frame
);
248 render_passes_in_draw_order
->clear();
251 gfx::Rect
DirectRenderer::ComputeScissorRectForRenderPass(
252 const DrawingFrame
* frame
) {
253 gfx::Rect render_pass_scissor
= frame
->current_render_pass
->output_rect
;
255 if (frame
->root_damage_rect
== frame
->root_render_pass
->output_rect
||
256 !frame
->current_render_pass
->copy_requests
.empty())
257 return render_pass_scissor
;
259 gfx::Transform
inverse_transform(gfx::Transform::kSkipInitialization
);
260 if (frame
->current_render_pass
->transform_to_root_target
.GetInverse(
261 &inverse_transform
)) {
262 // Only intersect inverse-projected damage if the transform is invertible.
263 gfx::Rect damage_rect_in_render_pass_space
=
264 MathUtil::ProjectEnclosingClippedRect(inverse_transform
,
265 frame
->root_damage_rect
);
266 render_pass_scissor
.Intersect(damage_rect_in_render_pass_space
);
269 return render_pass_scissor
;
272 bool DirectRenderer::NeedDeviceClip(const DrawingFrame
* frame
) const {
273 if (frame
->current_render_pass
!= frame
->root_render_pass
)
276 return !frame
->device_clip_rect
.Contains(frame
->device_viewport_rect
);
279 gfx::Rect
DirectRenderer::DeviceClipRectInWindowSpace(const DrawingFrame
* frame
)
281 gfx::Rect device_clip_rect
= frame
->device_clip_rect
;
282 if (FlippedFramebuffer())
283 device_clip_rect
.set_y(current_surface_size_
.height() -
284 device_clip_rect
.bottom());
285 return device_clip_rect
;
288 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame
* frame
,
289 const DrawQuad
& quad
) {
290 if (quad
.isClipped()) {
291 SetScissorTestRectInDrawSpace(frame
, quad
.clipRect());
294 if (NeedDeviceClip(frame
)) {
295 SetScissorTestRect(DeviceClipRectInWindowSpace(frame
));
299 EnsureScissorTestDisabled();
302 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
303 const DrawingFrame
* frame
,
304 const DrawQuad
& quad
,
305 const gfx::Rect
& render_pass_scissor
,
306 bool* should_skip_quad
) {
307 gfx::Rect quad_scissor_rect
= render_pass_scissor
;
309 if (quad
.isClipped())
310 quad_scissor_rect
.Intersect(quad
.clipRect());
312 if (quad_scissor_rect
.IsEmpty()) {
313 *should_skip_quad
= true;
317 *should_skip_quad
= false;
318 SetScissorTestRectInDrawSpace(frame
, quad_scissor_rect
);
321 void DirectRenderer::SetScissorTestRectInDrawSpace(
322 const DrawingFrame
* frame
,
323 const gfx::Rect
& draw_space_rect
) {
324 gfx::Rect window_space_rect
= MoveFromDrawToWindowSpace(draw_space_rect
);
325 if (NeedDeviceClip(frame
))
326 window_space_rect
.Intersect(DeviceClipRectInWindowSpace(frame
));
327 SetScissorTestRect(window_space_rect
);
330 void DirectRenderer::FinishDrawingQuadList() {}
332 void DirectRenderer::DrawRenderPass(DrawingFrame
* frame
,
333 const RenderPass
* render_pass
) {
334 TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
335 if (!UseRenderPass(frame
, render_pass
))
338 bool using_scissor_as_optimization
= Capabilities().using_partial_swap
;
339 gfx::Rect 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;
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;
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();
362 bool has_external_stencil_test
=
363 output_surface_
->HasExternalStencilTest() &&
364 frame
->current_render_pass
== frame
->root_render_pass
;
366 DiscardPixels(has_external_stencil_test
, draw_rect_covers_full_surface
);
367 ClearFramebuffer(frame
, has_external_stencil_test
);
370 const QuadList
& quad_list
= render_pass
->quad_list
;
371 for (QuadList::ConstBackToFrontIterator it
= quad_list
.BackToFrontBegin();
372 it
!= quad_list
.BackToFrontEnd();
374 const DrawQuad
& quad
= *(*it
);
375 bool should_skip_quad
= false;
377 if (using_scissor_as_optimization
) {
378 SetScissorStateForQuadWithRenderPassScissor(
379 frame
, quad
, render_pass_scissor
, &should_skip_quad
);
381 SetScissorStateForQuad(frame
, quad
);
384 if (!should_skip_quad
)
385 DoDrawQuad(frame
, *it
);
387 FinishDrawingQuadList();
390 bool DirectRenderer::UseRenderPass(DrawingFrame
* frame
,
391 const RenderPass
* render_pass
) {
392 frame
->current_render_pass
= render_pass
;
393 frame
->current_texture
= NULL
;
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());
404 ScopedResource
* texture
= render_pass_textures_
.get(render_pass
->id
);
407 gfx::Size size
= RenderPassTextureSize(render_pass
);
408 size
.Enlarge(enlarge_pass_texture_amount_
.x(),
409 enlarge_pass_texture_amount_
.y());
412 size
, ResourceProvider::TextureUsageFramebuffer
, RGBA_8888
);
413 DCHECK(texture
->id());
415 return BindFramebufferToTexture(frame
, texture
, render_pass
->output_rect
);
418 void DirectRenderer::RunOnDemandRasterTask(Task
* on_demand_raster_task
) {
419 TaskGraphRunner
* task_graph_runner
= RasterWorkerPool::GetTaskGraphRunner();
420 DCHECK(task_graph_runner
);
422 // Make sure we have a unique task namespace token.
423 if (!on_demand_task_namespace_
.IsValid())
424 on_demand_task_namespace_
= task_graph_runner
->GetNamespaceToken();
426 // Construct a task graph that contains this single raster task.
428 graph
.nodes
.push_back(
429 TaskGraph::Node(on_demand_raster_task
,
430 RasterWorkerPool::kOnDemandRasterTaskPriority
,
433 // Schedule task and wait for task graph runner to finish running it.
434 task_graph_runner
->ScheduleTasks(on_demand_task_namespace_
, &graph
);
435 task_graph_runner
->WaitForTasksToFinishRunning(on_demand_task_namespace_
);
437 // Collect task now that it has finished running.
438 Task::Vector completed_tasks
;
439 task_graph_runner
->CollectCompletedTasks(on_demand_task_namespace_
,
441 DCHECK_EQ(1u, completed_tasks
.size());
442 DCHECK_EQ(completed_tasks
[0], on_demand_raster_task
);
445 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPass::Id id
)
447 ScopedResource
* texture
= render_pass_textures_
.get(id
);
448 return texture
&& texture
->id();
452 gfx::Size
DirectRenderer::RenderPassTextureSize(const RenderPass
* render_pass
) {
453 return render_pass
->output_rect
.size();