cc/quads/render_pass.cc

   1 // Copyright 2011 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/quads/render_pass.h"
   6
   7 #include "base/debug/trace_event_argument.h"
   8 #include "base/values.h"
   9 #include "cc/base/math_util.h"
  10 #include "cc/debug/traced_value.h"
  11 #include "cc/output/copy_output_request.h"
  12 #include "cc/quads/checkerboard_draw_quad.h"
  13 #include "cc/quads/debug_border_draw_quad.h"
  14 #include "cc/quads/draw_quad.h"
  15 #include "cc/quads/io_surface_draw_quad.h"
  16 #include "cc/quads/picture_draw_quad.h"
  17 #include "cc/quads/render_pass_draw_quad.h"
  18 #include "cc/quads/shared_quad_state.h"
  19 #include "cc/quads/solid_color_draw_quad.h"
  20 #include "cc/quads/stream_video_draw_quad.h"
  21 #include "cc/quads/surface_draw_quad.h"
  22 #include "cc/quads/texture_draw_quad.h"
  23 #include "cc/quads/tile_draw_quad.h"
  24 #include "cc/quads/yuv_video_draw_quad.h"
  25
  26 namespace {
  27 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
  28 const size_t kDefaultNumQuadsToReserve = 128;
  29 }
  30
  31 namespace cc {
  32
  33 scoped_ptr<RenderPass> RenderPass::Create() {
  34   return make_scoped_ptr(new RenderPass());
  35 }
  36
  37 scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
  38   return make_scoped_ptr(new RenderPass(num_layers));
  39 }
  40
  41 RenderPass::RenderPass()
  42     : id(RenderPassId(-1, -1)), has_transparent_background(true) {
  43   shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
  44   quad_list.reserve(kDefaultNumQuadsToReserve);
  45 }
  46
  47 RenderPass::RenderPass(size_t num_layers)
  48     : id(RenderPassId(-1, -1)), has_transparent_background(true) {
  49   // Each layer usually produces one shared quad state, so the number of layers
  50   // is a good hint for what to reserve here.
  51   shared_quad_state_list.reserve(num_layers);
  52   quad_list.reserve(kDefaultNumQuadsToReserve);
  53 }
  54
  55 RenderPass::~RenderPass() {
  56   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
  57       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
  58       "cc::RenderPass", id.AsTracingId());
  59 }
  60
  61 scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
  62   scoped_ptr<RenderPass> copy_pass(Create());
  63   copy_pass->SetAll(new_id,
  64                     output_rect,
  65                     damage_rect,
  66                     transform_to_root_target,
  67                     has_transparent_background);
  68   return copy_pass.Pass();
  69 }
  70
  71 // static
  72 void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
  73                          ScopedPtrVector<RenderPass>* out) {
  74   for (size_t i = 0; i < in.size(); ++i) {
  75     RenderPass* source = in[i];
  76
  77     // Since we can't copy these, it's wrong to use CopyAll in a situation where
  78     // you may have copy_requests present.
  79     DCHECK_EQ(source->copy_requests.size(), 0u);
  80
  81     scoped_ptr<RenderPass> copy_pass(Create());
  82     copy_pass->SetAll(source->id,
  83                       source->output_rect,
  84                       source->damage_rect,
  85                       source->transform_to_root_target,
  86                       source->has_transparent_background);
  87     for (size_t i = 0; i < source->shared_quad_state_list.size(); ++i) {
  88       SharedQuadState* copy_shared_quad_state =
  89           copy_pass->CreateAndAppendSharedQuadState();
  90       copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
  91     }
  92     for (size_t i = 0, sqs_i = 0; i < source->quad_list.size(); ++i) {
  93       while (source->quad_list[i]->shared_quad_state !=
  94              source->shared_quad_state_list[sqs_i]) {
  95         ++sqs_i;
  96         DCHECK_LT(sqs_i, source->shared_quad_state_list.size());
  97       }
  98       DCHECK(source->quad_list[i]->shared_quad_state ==
  99              source->shared_quad_state_list[sqs_i]);
 100
 101       DrawQuad* quad = source->quad_list[i];
 102
 103       if (quad->material == DrawQuad::RENDER_PASS) {
 104         const RenderPassDrawQuad* pass_quad =
 105             RenderPassDrawQuad::MaterialCast(quad);
 106         copy_pass->CopyFromAndAppendRenderPassDrawQuad(
 107             pass_quad,
 108             copy_pass->shared_quad_state_list[sqs_i],
 109             pass_quad->render_pass_id);
 110       } else {
 111         copy_pass->CopyFromAndAppendDrawQuad(
 112             quad, copy_pass->shared_quad_state_list[sqs_i]);
 113       }
 114     }
 115     out->push_back(copy_pass.Pass());
 116   }
 117 }
 118
 119 void RenderPass::SetNew(RenderPassId id,
 120                         const gfx::Rect& output_rect,
 121                         const gfx::Rect& damage_rect,
 122                         const gfx::Transform& transform_to_root_target) {
 123   DCHECK_GT(id.layer_id, 0);
 124   DCHECK_GE(id.index, 0);
 125   DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
 126       << "damage_rect: " << damage_rect.ToString()
 127       << " output_rect: " << output_rect.ToString();
 128
 129   this->id = id;
 130   this->output_rect = output_rect;
 131   this->damage_rect = damage_rect;
 132   this->transform_to_root_target = transform_to_root_target;
 133
 134   DCHECK(quad_list.empty());
 135   DCHECK(shared_quad_state_list.empty());
 136 }
 137
 138 void RenderPass::SetAll(RenderPassId id,
 139                         const gfx::Rect& output_rect,
 140                         const gfx::Rect& damage_rect,
 141                         const gfx::Transform& transform_to_root_target,
 142                         bool has_transparent_background) {
 143   DCHECK_GT(id.layer_id, 0);
 144   DCHECK_GE(id.index, 0);
 145
 146   this->id = id;
 147   this->output_rect = output_rect;
 148   this->damage_rect = damage_rect;
 149   this->transform_to_root_target = transform_to_root_target;
 150   this->has_transparent_background = has_transparent_background;
 151
 152   DCHECK(quad_list.empty());
 153   DCHECK(shared_quad_state_list.empty());
 154 }
 155
 156 void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
 157   value->BeginArray("output_rect");
 158   MathUtil::AddToTracedValue(output_rect, value);
 159   value->EndArray();
 160
 161   value->BeginArray("damage_rect");
 162   MathUtil::AddToTracedValue(damage_rect, value);
 163   value->EndArray();
 164
 165   value->SetBoolean("has_transparent_background", has_transparent_background);
 166   value->SetInteger("copy_requests", copy_requests.size());
 167
 168   value->BeginArray("shared_quad_state_list");
 169   for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
 170     value->BeginDictionary();
 171     shared_quad_state_list[i]->AsValueInto(value);
 172     value->EndDictionary();
 173   }
 174   value->EndArray();
 175
 176   value->BeginArray("quad_list");
 177   for (size_t i = 0; i < quad_list.size(); ++i) {
 178     value->BeginDictionary();
 179     quad_list[i]->AsValueInto(value);
 180     value->EndDictionary();
 181   }
 182   value->EndArray();
 183
 184   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
 185       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
 186       value,
 187       "cc::RenderPass",
 188       id.AsTracingId());
 189 }
 190
 191 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
 192   shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
 193   return shared_quad_state_list.back();
 194 }
 195
 196 RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
 197     const RenderPassDrawQuad* quad,
 198     const SharedQuadState* shared_quad_state,
 199     RenderPassId render_pass_id) {
 200   RenderPassDrawQuad* copy_quad =
 201       CopyFromAndAppendTypedDrawQuad<RenderPassDrawQuad>(quad);
 202   copy_quad->shared_quad_state = shared_quad_state;
 203   copy_quad->render_pass_id = render_pass_id;
 204   return copy_quad;
 205 }
 206
 207 DrawQuad* RenderPass::CopyFromAndAppendDrawQuad(
 208     const DrawQuad* quad,
 209     const SharedQuadState* shared_quad_state) {
 210   switch (quad->material) {
 211     case DrawQuad::CHECKERBOARD:
 212       CopyFromAndAppendTypedDrawQuad<CheckerboardDrawQuad>(quad);
 213       break;
 214     case DrawQuad::DEBUG_BORDER:
 215       CopyFromAndAppendTypedDrawQuad<DebugBorderDrawQuad>(quad);
 216       break;
 217     case DrawQuad::IO_SURFACE_CONTENT:
 218       CopyFromAndAppendTypedDrawQuad<IOSurfaceDrawQuad>(quad);
 219       break;
 220     case DrawQuad::PICTURE_CONTENT:
 221       CopyFromAndAppendTypedDrawQuad<PictureDrawQuad>(quad);
 222       break;
 223     case DrawQuad::TEXTURE_CONTENT:
 224       CopyFromAndAppendTypedDrawQuad<TextureDrawQuad>(quad);
 225       break;
 226     case DrawQuad::SOLID_COLOR:
 227       CopyFromAndAppendTypedDrawQuad<SolidColorDrawQuad>(quad);
 228       break;
 229     case DrawQuad::TILED_CONTENT:
 230       CopyFromAndAppendTypedDrawQuad<TileDrawQuad>(quad);
 231       break;
 232     case DrawQuad::STREAM_VIDEO_CONTENT:
 233       CopyFromAndAppendTypedDrawQuad<StreamVideoDrawQuad>(quad);
 234       break;
 235     case DrawQuad::SURFACE_CONTENT:
 236       CopyFromAndAppendTypedDrawQuad<SurfaceDrawQuad>(quad);
 237       break;
 238     case DrawQuad::YUV_VIDEO_CONTENT:
 239       CopyFromAndAppendTypedDrawQuad<YUVVideoDrawQuad>(quad);
 240       break;
 241     // RenderPass quads need to use specific CopyFrom function.
 242     case DrawQuad::RENDER_PASS:
 243     case DrawQuad::INVALID:
 244       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
 245       break;
 246   }
 247   quad_list.back()->shared_quad_state = shared_quad_state;
 248   return quad_list.back();
 249 }
 250
 251 }  // namespace cc