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 "ui/gfx/rect_conversions.h"
18 #include "ui/gfx/transform.h"
20 static gfx::Transform
OrthoProjectionMatrix(float left
,
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
;
29 if (!delta_x
|| !delta_y
)
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
);
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);
43 static gfx::Transform
window_matrix(int x
, int y
, int width
, int height
) {
44 gfx::Transform canvas
;
46 // Map to window position and scale up to pixel coordinates.
47 canvas
.Translate3d(x
, y
, 0);
48 canvas
.Scale3d(width
, height
, 0);
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);
59 DirectRenderer::DrawingFrame::DrawingFrame()
60 : root_render_pass(NULL
),
61 current_render_pass(NULL
),
62 current_texture(NULL
),
63 offscreen_context_provider(NULL
) {}
65 DirectRenderer::DrawingFrame::~DrawingFrame() {}
69 gfx::RectF
DirectRenderer::QuadVertexRect() {
70 return gfx::RectF(-0.5f
, -0.5f
, 1.f
, 1.f
);
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());
83 void DirectRenderer::InitializeViewport(DrawingFrame
* frame
,
85 gfx::Rect viewport_rect
,
86 gfx::Size surface_size
) {
87 bool flip_y
= FlippedFramebuffer();
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());
94 frame
->projection_matrix
= OrthoProjectionMatrix(draw_rect
.x(),
99 frame
->projection_matrix
= OrthoProjectionMatrix(draw_rect
.x(),
105 gfx::Rect window_rect
= viewport_rect
;
107 window_rect
.set_y(surface_size
.height() - viewport_rect
.bottom());
108 frame
->window_matrix
= window_matrix(window_rect
.x(),
111 window_rect
.height());
112 SetDrawViewport(window_rect
);
114 current_draw_rect_
= draw_rect
;
115 current_viewport_rect_
= viewport_rect
;
116 current_surface_size_
= surface_size
;
119 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());
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
) {}
137 DirectRenderer::~DirectRenderer() {}
139 bool DirectRenderer::CanReadPixels() const { return true; }
141 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
142 gfx::Vector2d amount
) {
143 enlarge_pass_texture_amount_
= amount
;
146 void DirectRenderer::DecideRenderPassAllocationsForFrame(
147 const RenderPassList
& render_passes_in_draw_order
) {
148 if (!resource_provider_
)
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
])));
157 std::vector
<RenderPass::Id
> passes_to_delete
;
158 base::ScopedPtrHashMap
<RenderPass::Id
, ScopedResource
>::const_iterator
160 for (pass_iter
= render_pass_textures_
.begin();
161 pass_iter
!= render_pass_textures_
.end();
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
);
170 gfx::Size required_size
= it
->second
;
171 ScopedResource
* texture
= pass_iter
->second
;
174 bool size_appropriate
= texture
->size().width() >= required_size
.width() &&
175 texture
->size().height() >= required_size
.height();
176 if (texture
->id() && !size_appropriate
)
180 // Delete RenderPass textures from the previous frame that will not be used
182 for (size_t i
= 0; i
< passes_to_delete
.size(); ++i
)
183 render_pass_textures_
.erase(passes_to_delete
[i
]);
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
,
195 void DirectRenderer::DrawFrame(RenderPassList
* render_passes_in_draw_order
,
196 ContextProvider
* offscreen_context_provider
,
197 float device_scale_factor
,
198 bool allow_partial_swap
,
199 bool disable_picture_quad_image_filtering
) {
200 TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
201 UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
202 render_passes_in_draw_order
->size());
204 const RenderPass
* root_render_pass
= render_passes_in_draw_order
->back();
205 DCHECK(root_render_pass
);
208 frame
.root_render_pass
= root_render_pass
;
209 frame
.root_damage_rect
=
210 Capabilities().using_partial_swap
&& allow_partial_swap
211 ? root_render_pass
->damage_rect
212 : root_render_pass
->output_rect
;
213 frame
.root_damage_rect
.Intersect(gfx::Rect(client_
->DeviceViewport().size()));
214 frame
.offscreen_context_provider
= offscreen_context_provider
;
215 frame
.disable_picture_quad_image_filtering
=
216 disable_picture_quad_image_filtering
;
220 // Only reshape when we know we are going to draw. Otherwise, the reshape
221 // can leave the window at the wrong size if we never draw and the proper
222 // viewport size is never set.
223 output_surface_
->Reshape(client_
->DeviceViewport().size(),
224 device_scale_factor
);
226 BeginDrawingFrame(&frame
);
227 for (size_t i
= 0; i
< render_passes_in_draw_order
->size(); ++i
) {
228 RenderPass
* pass
= render_passes_in_draw_order
->at(i
);
229 DrawRenderPass(&frame
, pass
, allow_partial_swap
);
231 for (ScopedPtrVector
<CopyOutputRequest
>::iterator it
=
232 pass
->copy_requests
.begin();
233 it
!= pass
->copy_requests
.end();
236 // Doing a readback is destructive of our state on Mac, so make sure
237 // we restore the state between readbacks. http://crbug.com/99393.
238 UseRenderPass(&frame
, pass
);
240 CopyCurrentRenderPassToBitmap(&frame
, pass
->copy_requests
.take(it
));
243 FinishDrawingFrame(&frame
);
245 render_passes_in_draw_order
->clear();
248 gfx::RectF
DirectRenderer::ComputeScissorRectForRenderPass(
249 const DrawingFrame
* frame
) {
250 gfx::RectF render_pass_scissor
= frame
->current_render_pass
->output_rect
;
252 if (frame
->root_damage_rect
== frame
->root_render_pass
->output_rect
)
253 return render_pass_scissor
;
255 gfx::Transform
inverse_transform(gfx::Transform::kSkipInitialization
);
256 if (frame
->current_render_pass
->transform_to_root_target
.GetInverse(
257 &inverse_transform
)) {
258 // Only intersect inverse-projected damage if the transform is invertible.
259 gfx::RectF damage_rect_in_render_pass_space
=
260 MathUtil::ProjectClippedRect(inverse_transform
,
261 frame
->root_damage_rect
);
262 render_pass_scissor
.Intersect(damage_rect_in_render_pass_space
);
265 return render_pass_scissor
;
268 bool DirectRenderer::NeedDeviceClip(const DrawingFrame
* frame
) const {
269 if (frame
->current_render_pass
!= frame
->root_render_pass
)
272 return !client_
->DeviceClip().Contains(client_
->DeviceViewport());
275 gfx::Rect
DirectRenderer::DeviceClipRect(const DrawingFrame
* frame
) const {
276 gfx::Rect device_clip_rect
= client_
->DeviceClip();
277 if (FlippedFramebuffer())
278 device_clip_rect
.set_y(current_surface_size_
.height() -
279 device_clip_rect
.bottom());
280 return device_clip_rect
;
283 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame
* frame
,
284 const DrawQuad
& quad
) {
285 if (quad
.isClipped()) {
286 SetScissorTestRectInDrawSpace(frame
, quad
.clipRect());
289 if (NeedDeviceClip(frame
)) {
290 SetScissorTestRect(DeviceClipRect(frame
));
294 EnsureScissorTestDisabled();
297 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
298 const DrawingFrame
* frame
,
299 const DrawQuad
& quad
,
300 const gfx::RectF
& render_pass_scissor
,
301 bool* should_skip_quad
) {
302 gfx::RectF quad_scissor_rect
= render_pass_scissor
;
304 if (quad
.isClipped())
305 quad_scissor_rect
.Intersect(quad
.clipRect());
307 if (quad_scissor_rect
.IsEmpty()) {
308 *should_skip_quad
= true;
312 *should_skip_quad
= false;
313 SetScissorTestRectInDrawSpace(frame
, quad_scissor_rect
);
316 void DirectRenderer::SetScissorTestRectInDrawSpace(const DrawingFrame
* frame
,
317 gfx::RectF draw_space_rect
) {
318 gfx::Rect window_space_rect
= MoveFromDrawToWindowSpace(draw_space_rect
);
319 if (NeedDeviceClip(frame
))
320 window_space_rect
.Intersect(DeviceClipRect(frame
));
321 SetScissorTestRect(window_space_rect
);
324 void DirectRenderer::FinishDrawingQuadList() {}
326 void DirectRenderer::DrawRenderPass(DrawingFrame
* frame
,
327 const RenderPass
* render_pass
,
328 bool allow_partial_swap
) {
329 TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
330 if (!UseRenderPass(frame
, render_pass
))
333 bool using_scissor_as_optimization
=
334 Capabilities().using_partial_swap
&& allow_partial_swap
;
335 gfx::RectF render_pass_scissor
;
336 bool draw_rect_covers_full_surface
= true;
337 if (frame
->current_render_pass
== frame
->root_render_pass
&&
338 !client_
->DeviceViewport().Contains(
339 gfx::Rect(output_surface_
->SurfaceSize())))
340 draw_rect_covers_full_surface
= false;
342 if (using_scissor_as_optimization
) {
343 render_pass_scissor
= ComputeScissorRectForRenderPass(frame
);
344 SetScissorTestRectInDrawSpace(frame
, render_pass_scissor
);
345 if (!render_pass_scissor
.Contains(frame
->current_render_pass
->output_rect
))
346 draw_rect_covers_full_surface
= false;
349 if (frame
->current_render_pass
!= frame
->root_render_pass
||
350 settings_
->should_clear_root_render_pass
) {
351 if (NeedDeviceClip(frame
)) {
352 SetScissorTestRect(DeviceClipRect(frame
));
353 draw_rect_covers_full_surface
= false;
354 } else if (!using_scissor_as_optimization
) {
355 EnsureScissorTestDisabled();
358 bool has_external_stencil_test
=
359 output_surface_
->HasExternalStencilTest() &&
360 frame
->current_render_pass
== frame
->root_render_pass
;
362 DiscardPixels(has_external_stencil_test
, draw_rect_covers_full_surface
);
363 ClearFramebuffer(frame
, has_external_stencil_test
);
366 const QuadList
& quad_list
= render_pass
->quad_list
;
367 for (QuadList::ConstBackToFrontIterator it
= quad_list
.BackToFrontBegin();
368 it
!= quad_list
.BackToFrontEnd();
370 const DrawQuad
& quad
= *(*it
);
371 bool should_skip_quad
= false;
373 if (using_scissor_as_optimization
) {
374 SetScissorStateForQuadWithRenderPassScissor(
375 frame
, quad
, render_pass_scissor
, &should_skip_quad
);
377 SetScissorStateForQuad(frame
, quad
);
380 if (!should_skip_quad
)
381 DoDrawQuad(frame
, *it
);
383 FinishDrawingQuadList();
386 bool DirectRenderer::UseRenderPass(DrawingFrame
* frame
,
387 const RenderPass
* render_pass
) {
388 frame
->current_render_pass
= render_pass
;
389 frame
->current_texture
= NULL
;
391 if (render_pass
== frame
->root_render_pass
) {
392 BindFramebufferToOutputSurface(frame
);
393 InitializeViewport(frame
,
394 render_pass
->output_rect
,
395 client_
->DeviceViewport(),
396 output_surface_
->SurfaceSize());
400 if (!resource_provider_
)
403 ScopedResource
* texture
= render_pass_textures_
.get(render_pass
->id
);
406 gfx::Size size
= RenderPassTextureSize(render_pass
);
407 size
.Enlarge(enlarge_pass_texture_amount_
.x(),
408 enlarge_pass_texture_amount_
.y());
409 if (!texture
->id() &&
411 size
, ResourceProvider::TextureUsageFramebuffer
, RGBA_8888
))
414 return BindFramebufferToTexture(frame
, texture
, render_pass
->output_rect
);
417 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPass::Id id
)
419 ScopedResource
* texture
= render_pass_textures_
.get(id
);
420 return texture
&& texture
->id();
424 gfx::Size
DirectRenderer::RenderPassTextureSize(const RenderPass
* render_pass
) {
425 return render_pass
->output_rect
.size();