cc/output/direct_renderer.cc

   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/metrics/histogram.h"
  13 #include "base/trace_event/trace_event.h"
  14 #include "cc/base/math_util.h"
  15 #include "cc/output/bsp_tree.h"
  16 #include "cc/output/bsp_walk_action.h"
  17 #include "cc/output/copy_output_request.h"
  18 #include "cc/quads/draw_quad.h"
  19 #include "ui/gfx/geometry/rect_conversions.h"
  20 #include "ui/gfx/transform.h"
  21
  22 static gfx::Transform OrthoProjectionMatrix(float left,
  23                                             float right,
  24                                             float bottom,
  25                                             float top) {
  26   // Use the standard formula to map the clipping frustum to the cube from
  27   // [-1, -1, -1] to [1, 1, 1].
  28   float delta_x = right - left;
  29   float delta_y = top - bottom;
  30   gfx::Transform proj;
  31   if (!delta_x || !delta_y)
  32     return proj;
  33   proj.matrix().set(0, 0, 2.0f / delta_x);
  34   proj.matrix().set(0, 3, -(right + left) / delta_x);
  35   proj.matrix().set(1, 1, 2.0f / delta_y);
  36   proj.matrix().set(1, 3, -(top + bottom) / delta_y);
  37
  38   // Z component of vertices is always set to zero as we don't use the depth
  39   // buffer while drawing.
  40   proj.matrix().set(2, 2, 0);
  41
  42   return proj;
  43 }
  44
  45 static gfx::Transform window_matrix(int x, int y, int width, int height) {
  46   gfx::Transform canvas;
  47
  48   // Map to window position and scale up to pixel coordinates.
  49   canvas.Translate3d(x, y, 0);
  50   canvas.Scale3d(width, height, 0);
  51
  52   // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
  53   canvas.Translate3d(0.5, 0.5, 0.5);
  54   canvas.Scale3d(0.5, 0.5, 0.5);
  55
  56   return canvas;
  57 }
  58
  59 namespace cc {
  60
  61 DirectRenderer::DrawingFrame::DrawingFrame()
  62     : root_render_pass(NULL), current_render_pass(NULL), current_texture(NULL) {
  63 }
  64
  65 DirectRenderer::DrawingFrame::~DrawingFrame() {}
  66
  67 //
  68 // static
  69 gfx::RectF DirectRenderer::QuadVertexRect() {
  70   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
  71 }
  72
  73 // static
  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
  83 void DirectRenderer::InitializeViewport(DrawingFrame* frame,
  84                                         const gfx::Rect& draw_rect,
  85                                         const gfx::Rect& viewport_rect,
  86                                         const gfx::Size& surface_size) {
  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   bool flip_y = FlippedFramebuffer(frame);
  92   if (flip_y) {
  93     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
  94                                                      draw_rect.right(),
  95                                                      draw_rect.bottom(),
  96                                                      draw_rect.y());
  97   } else {
  98     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
  99                                                      draw_rect.right(),
 100                                                      draw_rect.y(),
 101                                                      draw_rect.bottom());
 102   }
 103
 104   gfx::Rect window_rect = viewport_rect;
 105   if (flip_y)
 106     window_rect.set_y(surface_size.height() - viewport_rect.bottom());
 107   frame->window_matrix = window_matrix(window_rect.x(),
 108                                        window_rect.y(),
 109                                        window_rect.width(),
 110                                        window_rect.height());
 111   current_draw_rect_ = draw_rect;
 112   current_viewport_rect_ = viewport_rect;
 113   current_surface_size_ = surface_size;
 114   current_window_space_viewport_ = window_rect;
 115 }
 116
 117 gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
 118     const DrawingFrame* frame,
 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(frame))
 124     window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
 125   return window_rect;
 126 }
 127
 128 DirectRenderer::DirectRenderer(RendererClient* client,
 129                                const RendererSettings* settings,
 130                                OutputSurface* output_surface,
 131                                ResourceProvider* resource_provider)
 132     : Renderer(client, settings),
 133       output_surface_(output_surface),
 134       resource_provider_(resource_provider),
 135       overlay_processor_(
 136           new OverlayProcessor(output_surface, resource_provider)) {
 137   overlay_processor_->Initialize();
 138 }
 139
 140 DirectRenderer::~DirectRenderer() {}
 141
 142 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
 143     const gfx::Vector2d& amount) {
 144   enlarge_pass_texture_amount_ = amount;
 145 }
 146
 147 void DirectRenderer::DecideRenderPassAllocationsForFrame(
 148     const RenderPassList& render_passes_in_draw_order) {
 149   base::hash_map<RenderPassId, gfx::Size> render_passes_in_frame;
 150   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
 151     render_passes_in_frame.insert(std::pair<RenderPassId, gfx::Size>(
 152         render_passes_in_draw_order[i]->id,
 153         RenderPassTextureSize(render_passes_in_draw_order[i])));
 154
 155   std::vector<RenderPassId> passes_to_delete;
 156   for (auto pass_iter = render_pass_textures_.begin();
 157        pass_iter != render_pass_textures_.end(); ++pass_iter) {
 158     base::hash_map<RenderPassId, gfx::Size>::const_iterator it =
 159         render_passes_in_frame.find(pass_iter->first);
 160     if (it == render_passes_in_frame.end()) {
 161       passes_to_delete.push_back(pass_iter->first);
 162       continue;
 163     }
 164
 165     gfx::Size required_size = it->second;
 166     ScopedResource* texture = pass_iter->second;
 167     DCHECK(texture);
 168
 169     bool size_appropriate = texture->size().width() >= required_size.width() &&
 170                             texture->size().height() >= required_size.height();
 171     if (texture->id() && !size_appropriate)
 172       texture->Free();
 173   }
 174
 175   // Delete RenderPass textures from the previous frame that will not be used
 176   // again.
 177   for (size_t i = 0; i < passes_to_delete.size(); ++i)
 178     render_pass_textures_.erase(passes_to_delete[i]);
 179
 180   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
 181     if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
 182       scoped_ptr<ScopedResource> texture =
 183           ScopedResource::Create(resource_provider_);
 184       render_pass_textures_.set(render_passes_in_draw_order[i]->id,
 185                               texture.Pass());
 186     }
 187   }
 188 }
 189
 190 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
 191                                float device_scale_factor,
 192                                const gfx::Rect& device_viewport_rect,
 193                                const gfx::Rect& device_clip_rect,
 194                                bool disable_picture_quad_image_filtering) {
 195   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
 196   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
 197                        render_passes_in_draw_order->size());
 198
 199   const RenderPass* root_render_pass = render_passes_in_draw_order->back();
 200   DCHECK(root_render_pass);
 201
 202   DrawingFrame frame;
 203   frame.render_passes_in_draw_order = render_passes_in_draw_order;
 204   frame.root_render_pass = root_render_pass;
 205   frame.root_damage_rect = Capabilities().using_partial_swap
 206                                ? root_render_pass->damage_rect
 207                                : root_render_pass->output_rect;
 208   frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_rect.size()));
 209   frame.device_viewport_rect = device_viewport_rect;
 210   frame.device_clip_rect = device_clip_rect;
 211   frame.disable_picture_quad_image_filtering =
 212       disable_picture_quad_image_filtering;
 213
 214   EnsureBackbuffer();
 215
 216   // Only reshape when we know we are going to draw. Otherwise, the reshape
 217   // can leave the window at the wrong size if we never draw and the proper
 218   // viewport size is never set.
 219   output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor);
 220
 221   BeginDrawingFrame(&frame);
 222
 223   // If we have any copy requests, we can't remove any quads for overlays,
 224   // otherwise the framebuffer will be missing the overlay contents.
 225   if (root_render_pass->copy_requests.empty()) {
 226     overlay_processor_->ProcessForOverlays(render_passes_in_draw_order,
 227                                            &frame.overlay_list);
 228   }
 229
 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 (it != pass->copy_requests.begin()) {
 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::DeviceClipRectInDrawSpace(
 280     const DrawingFrame* frame) const {
 281   gfx::Rect device_clip_rect = frame->device_clip_rect;
 282   device_clip_rect -= current_viewport_rect_.OffsetFromOrigin();
 283   device_clip_rect += current_draw_rect_.OffsetFromOrigin();
 284   return device_clip_rect;
 285 }
 286
 287 gfx::Rect DirectRenderer::DeviceViewportRectInDrawSpace(
 288     const DrawingFrame* frame) const {
 289   gfx::Rect device_viewport_rect = frame->device_viewport_rect;
 290   device_viewport_rect -= current_viewport_rect_.OffsetFromOrigin();
 291   device_viewport_rect += current_draw_rect_.OffsetFromOrigin();
 292   return device_viewport_rect;
 293 }
 294
 295 gfx::Rect DirectRenderer::OutputSurfaceRectInDrawSpace(
 296     const DrawingFrame* frame) const {
 297   if (frame->current_render_pass == frame->root_render_pass) {
 298     gfx::Rect output_surface_rect(output_surface_->SurfaceSize());
 299     output_surface_rect -= current_viewport_rect_.OffsetFromOrigin();
 300     output_surface_rect += current_draw_rect_.OffsetFromOrigin();
 301     return output_surface_rect;
 302   } else {
 303     return frame->current_render_pass->output_rect;
 304   }
 305 }
 306
 307 bool DirectRenderer::ShouldSkipQuad(const DrawQuad& quad,
 308                                     const gfx::Rect& render_pass_scissor) {
 309   if (render_pass_scissor.IsEmpty())
 310     return true;
 311
 312   if (quad.isClipped()) {
 313     gfx::Rect r = quad.clipRect();
 314     r.Intersect(render_pass_scissor);
 315     return r.IsEmpty();
 316   }
 317
 318   return false;
 319 }
 320
 321 void DirectRenderer::SetScissorStateForQuad(
 322     const DrawingFrame* frame,
 323     const DrawQuad& quad,
 324     const gfx::Rect& render_pass_scissor,
 325     bool use_render_pass_scissor) {
 326   if (use_render_pass_scissor) {
 327     gfx::Rect quad_scissor_rect = render_pass_scissor;
 328     if (quad.isClipped())
 329       quad_scissor_rect.Intersect(quad.clipRect());
 330     SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
 331     return;
 332   } else if (quad.isClipped()) {
 333     SetScissorTestRectInDrawSpace(frame, quad.clipRect());
 334     return;
 335   }
 336
 337   EnsureScissorTestDisabled();
 338 }
 339
 340 void DirectRenderer::SetScissorTestRectInDrawSpace(
 341     const DrawingFrame* frame,
 342     const gfx::Rect& draw_space_rect) {
 343   gfx::Rect window_space_rect =
 344       MoveFromDrawToWindowSpace(frame, draw_space_rect);
 345   SetScissorTestRect(window_space_rect);
 346 }
 347
 348 void DirectRenderer::FinishDrawingQuadList() {}
 349
 350 void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly,
 351                                    DrawingFrame* frame,
 352                                    const gfx::Rect& render_pass_scissor,
 353                                    bool use_render_pass_scissor) {
 354   SetScissorStateForQuad(frame, *poly.original_ref(), render_pass_scissor,
 355                          use_render_pass_scissor);
 356
 357   // If the poly has not been split, then it is just a normal DrawQuad,
 358   // and we should save any extra processing that would have to be done.
 359   if (!poly.is_split()) {
 360     DoDrawQuad(frame, poly.original_ref(), NULL);
 361     return;
 362   }
 363
 364   std::vector<gfx::QuadF> quads;
 365   poly.ToQuads2D(&quads);
 366   for (size_t i = 0; i < quads.size(); ++i) {
 367     DoDrawQuad(frame, poly.original_ref(), &quads[i]);
 368   }
 369 }
 370
 371 void DirectRenderer::FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list,
 372                                    DrawingFrame* frame,
 373                                    const gfx::Rect& render_pass_scissor,
 374                                    bool use_render_pass_scissor) {
 375   if (poly_list->empty()) {
 376     return;
 377   }
 378
 379   BspTree bsp_tree(poly_list);
 380   BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
 381                                           use_render_pass_scissor);
 382   bsp_tree.TraverseWithActionHandler(&action_handler);
 383   DCHECK(poly_list->empty());
 384 }
 385
 386 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
 387                                     const RenderPass* render_pass) {
 388   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
 389   if (!UseRenderPass(frame, render_pass))
 390     return;
 391
 392   const gfx::Rect surface_rect_in_draw_space =
 393       OutputSurfaceRectInDrawSpace(frame);
 394   gfx::Rect render_pass_scissor_in_draw_space = surface_rect_in_draw_space;
 395
 396   if (frame->current_render_pass == frame->root_render_pass) {
 397     render_pass_scissor_in_draw_space.Intersect(
 398         DeviceViewportRectInDrawSpace(frame));
 399   }
 400
 401   if (Capabilities().using_partial_swap) {
 402     render_pass_scissor_in_draw_space.Intersect(
 403         ComputeScissorRectForRenderPass(frame));
 404   }
 405
 406   if (NeedDeviceClip(frame)) {
 407     render_pass_scissor_in_draw_space.Intersect(
 408         DeviceClipRectInDrawSpace(frame));
 409   }
 410
 411   bool render_pass_is_clipped =
 412       !render_pass_scissor_in_draw_space.Contains(surface_rect_in_draw_space);
 413   bool is_root_render_pass =
 414       frame->current_render_pass == frame->root_render_pass;
 415   bool has_external_stencil_test =
 416       is_root_render_pass && output_surface_->HasExternalStencilTest();
 417   bool should_clear_surface =
 418       !has_external_stencil_test &&
 419       (!is_root_render_pass || settings_->should_clear_root_render_pass);
 420
 421   // If |has_external_stencil_test| we can't discard or clear. Make sure we
 422   // don't need to.
 423   DCHECK_IMPLIES(has_external_stencil_test,
 424                  !frame->current_render_pass->has_transparent_background);
 425
 426   SurfaceInitializationMode mode;
 427   if (should_clear_surface && render_pass_is_clipped) {
 428     mode = SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR;
 429   } else if (should_clear_surface) {
 430     mode = SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR;
 431   } else {
 432     mode = SURFACE_INITIALIZATION_MODE_PRESERVE;
 433   }
 434
 435   PrepareSurfaceForPass(
 436       frame, mode,
 437       MoveFromDrawToWindowSpace(frame, render_pass_scissor_in_draw_space));
 438
 439   const QuadList& quad_list = render_pass->quad_list;
 440   ScopedPtrDeque<DrawPolygon> poly_list;
 441
 442   int next_polygon_id = 0;
 443   int last_sorting_context_id = 0;
 444   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
 445        ++it) {
 446     const DrawQuad& quad = **it;
 447     gfx::QuadF send_quad(quad.visible_rect);
 448
 449     if (render_pass_is_clipped &&
 450         ShouldSkipQuad(quad, render_pass_scissor_in_draw_space)) {
 451       continue;
 452     }
 453
 454     if (last_sorting_context_id != quad.shared_quad_state->sorting_context_id) {
 455       last_sorting_context_id = quad.shared_quad_state->sorting_context_id;
 456       FlushPolygons(&poly_list, frame, render_pass_scissor_in_draw_space,
 457                     render_pass_is_clipped);
 458     }
 459
 460     // This layer is in a 3D sorting context so we add it to the list of
 461     // polygons to go into the BSP tree.
 462     if (quad.shared_quad_state->sorting_context_id != 0) {
 463       scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
 464           *it, quad.visible_rect, quad.quadTransform(), next_polygon_id++));
 465       if (new_polygon->points().size() > 2u) {
 466         poly_list.push_back(new_polygon.Pass());
 467       }
 468       continue;
 469     }
 470
 471     // We are not in a 3d sorting context, so we should draw the quad normally.
 472     SetScissorStateForQuad(frame, quad, render_pass_scissor_in_draw_space,
 473                            render_pass_is_clipped);
 474
 475     DoDrawQuad(frame, &quad, nullptr);
 476   }
 477   FlushPolygons(&poly_list, frame, render_pass_scissor_in_draw_space,
 478                 render_pass_is_clipped);
 479   FinishDrawingQuadList();
 480 }
 481
 482 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
 483                                    const RenderPass* render_pass) {
 484   frame->current_render_pass = render_pass;
 485   frame->current_texture = NULL;
 486   if (render_pass == frame->root_render_pass) {
 487     BindFramebufferToOutputSurface(frame);
 488     InitializeViewport(frame,
 489                        render_pass->output_rect,
 490                        frame->device_viewport_rect,
 491                        output_surface_->SurfaceSize());
 492     return true;
 493   }
 494
 495   ScopedResource* texture = render_pass_textures_.get(render_pass->id);
 496   DCHECK(texture);
 497
 498   gfx::Size size = RenderPassTextureSize(render_pass);
 499   size.Enlarge(enlarge_pass_texture_amount_.x(),
 500                enlarge_pass_texture_amount_.y());
 501   if (!texture->id()) {
 502     texture->Allocate(
 503         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, RGBA_8888);
 504   }
 505   DCHECK(texture->id());
 506
 507   if (BindFramebufferToTexture(frame, texture, render_pass->output_rect)) {
 508     InitializeViewport(frame, render_pass->output_rect,
 509                        gfx::Rect(render_pass->output_rect.size()),
 510                        render_pass->output_rect.size());
 511     return true;
 512   }
 513
 514   return false;
 515 }
 516
 517 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPassId id) const {
 518   ScopedResource* texture = render_pass_textures_.get(id);
 519   return texture && texture->id();
 520 }
 521
 522 // static
 523 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
 524   return render_pass->output_rect.size();
 525 }
 526
 527 }  // namespace cc