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/geometry/rect_conversions.h" 18 #include "ui/gfx/transform.h" 19 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 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 59 DirectRenderer::DrawingFrame::DrawingFrame() 60 : root_render_pass(NULL), current_render_pass(NULL), current_texture(NULL) { 61 } 62 63 DirectRenderer::DrawingFrame::~DrawingFrame() {} 64 65 // 66 // static 67 gfx::RectF DirectRenderer::QuadVertexRect() { 68 return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f); 69 } 70 71 // static 72 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform, 73 const gfx::Transform& quad_transform, 74 const gfx::RectF& quad_rect) { 75 *quad_rect_transform = quad_transform; 76 quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(), 77 0.5 * quad_rect.height() + quad_rect.y()); 78 quad_rect_transform->Scale(quad_rect.width(), quad_rect.height()); 79 } 80 81 void DirectRenderer::InitializeViewport(DrawingFrame* frame, 82 const gfx::Rect& draw_rect, 83 const gfx::Rect& viewport_rect, 84 const gfx::Size& surface_size) { 85 bool flip_y = FlippedFramebuffer(); 86 87 DCHECK_GE(viewport_rect.x(), 0); 88 DCHECK_GE(viewport_rect.y(), 0); 89 DCHECK_LE(viewport_rect.right(), surface_size.width()); 90 DCHECK_LE(viewport_rect.bottom(), surface_size.height()); 91 if (flip_y) { 92 frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(), 93 draw_rect.right(), 94 draw_rect.bottom(), 95 draw_rect.y()); 96 } else { 97 frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(), 98 draw_rect.right(), 99 draw_rect.y(), 100 draw_rect.bottom()); 101 } 102 103 gfx::Rect window_rect = viewport_rect; 104 if (flip_y) 105 window_rect.set_y(surface_size.height() - viewport_rect.bottom()); 106 frame->window_matrix = window_matrix(window_rect.x(), 107 window_rect.y(), 108 window_rect.width(), 109 window_rect.height()); 110 SetDrawViewport(window_rect); 111 112 current_draw_rect_ = draw_rect; 113 current_viewport_rect_ = viewport_rect; 114 current_surface_size_ = surface_size; 115 } 116 117 gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace( 118 const gfx::Rect& draw_rect) const { 119 gfx::Rect window_rect = draw_rect; 120 window_rect -= current_draw_rect_.OffsetFromOrigin(); 121 window_rect += current_viewport_rect_.OffsetFromOrigin(); 122 if (FlippedFramebuffer()) 123 window_rect.set_y(current_surface_size_.height() - window_rect.bottom()); 124 return window_rect; 125 } 126 127 DirectRenderer::DirectRenderer(RendererClient* client, 128 const LayerTreeSettings* settings, 129 OutputSurface* output_surface, 130 ResourceProvider* resource_provider) 131 : Renderer(client, settings), 132 output_surface_(output_surface), 133 resource_provider_(resource_provider), 134 overlay_processor_( 135 new OverlayProcessor(output_surface, resource_provider)) { 136 overlay_processor_->Initialize(); 137 } 138 139 DirectRenderer::~DirectRenderer() {} 140 141 void DirectRenderer::SetEnlargePassTextureAmountForTesting( 142 const gfx::Vector2d& amount) { 143 enlarge_pass_texture_amount_ = amount; 144 } 145 146 void DirectRenderer::DecideRenderPassAllocationsForFrame( 147 const RenderPassList& render_passes_in_draw_order) { 148 if (!resource_provider_) 149 return; 150 151 base::hash_map<RenderPassId, 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<RenderPassId, gfx::Size>( 154 render_passes_in_draw_order[i]->id, 155 RenderPassTextureSize(render_passes_in_draw_order[i]))); 156 157 std::vector<RenderPassId> passes_to_delete; 158 base::ScopedPtrHashMap<RenderPassId, 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<RenderPassId, 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 195 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order, 196 float device_scale_factor, 197 const gfx::Rect& device_viewport_rect, 198 const gfx::Rect& device_clip_rect, 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()); 203 204 const RenderPass* root_render_pass = render_passes_in_draw_order->back(); 205 DCHECK(root_render_pass); 206 207 DrawingFrame frame; 208 frame.render_passes_in_draw_order = render_passes_in_draw_order; 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; 218 219 overlay_processor_->ProcessForOverlays(render_passes_in_draw_order, 220 &frame.overlay_list); 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); 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 251 gfx::Rect DirectRenderer::ComputeScissorRectForRenderPass( 252 const DrawingFrame* frame) { 253 gfx::Rect render_pass_scissor = frame->current_render_pass->output_rect; 254 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; 258 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); 267 } 268 269 return render_pass_scissor; 270 } 271 272 bool DirectRenderer::NeedDeviceClip(const DrawingFrame* frame) const { 273 if (frame->current_render_pass != frame->root_render_pass) 274 return false; 275 276 return !frame->device_clip_rect.Contains(frame->device_viewport_rect); 277 } 278 279 gfx::Rect DirectRenderer::DeviceClipRectInWindowSpace(const DrawingFrame* frame) 280 const { 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; 286 } 287 288 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame, 289 const DrawQuad& quad) { 290 if (quad.isClipped()) { 291 SetScissorTestRectInDrawSpace(frame, quad.clipRect()); 292 return; 293 } 294 if (NeedDeviceClip(frame)) { 295 SetScissorTestRect(DeviceClipRectInWindowSpace(frame)); 296 return; 297 } 298 299 EnsureScissorTestDisabled(); 300 } 301 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; 308 309 if (quad.isClipped()) 310 quad_scissor_rect.Intersect(quad.clipRect()); 311 312 if (quad_scissor_rect.IsEmpty()) { 313 *should_skip_quad = true; 314 return; 315 } 316 317 *should_skip_quad = false; 318 SetScissorTestRectInDrawSpace(frame, quad_scissor_rect); 319 } 320 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); 328 } 329 330 void DirectRenderer::FinishDrawingQuadList() {} 331 332 void DirectRenderer::DrawRenderPass(DrawingFrame* frame, 333 const RenderPass* render_pass) { 334 TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass"); 335 if (!UseRenderPass(frame, render_pass)) 336 return; 337 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; 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, &quad); 386 } 387 FinishDrawingQuadList(); 388 } 389 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::TextureHintImmutableFramebuffer, RGBA_8888); 413 DCHECK(texture->id()); 414 415 return BindFramebufferToTexture(frame, texture, render_pass->output_rect); 416 } 417 418 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPassId id) const { 419 ScopedResource* texture = render_pass_textures_.get(id); 420 return texture && texture->id(); 421 } 422 423 // static 424 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) { 425 return render_pass->output_rect.size(); 426 } 427 428 } // namespace cc 429