render_pass_test_common.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6 
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/test/render_pass_test_common.h"
6
7#include "cc/quads/checkerboard_draw_quad.h"
8#include "cc/quads/debug_border_draw_quad.h"
9#include "cc/quads/io_surface_draw_quad.h"
10#include "cc/quads/render_pass_draw_quad.h"
11#include "cc/quads/shared_quad_state.h"
12#include "cc/quads/solid_color_draw_quad.h"
13#include "cc/quads/stream_video_draw_quad.h"
14#include "cc/quads/texture_draw_quad.h"
15#include "cc/quads/tile_draw_quad.h"
16#include "cc/quads/yuv_video_draw_quad.h"
17#include "cc/resources/resource_provider.h"
18#include "ui/gfx/transform.h"
19
20namespace cc {
21
22void TestRenderPass::AppendQuad(scoped_ptr<cc::DrawQuad> quad) {
23  quad_list.push_back(quad.Pass());
24}
25
26void TestRenderPass::AppendSharedQuadState(
27    scoped_ptr<cc::SharedQuadState> state) {
28  shared_quad_state_list.push_back(state.Pass());
29}
30
31void TestRenderPass::AppendOneOfEveryQuadType(
32    cc::ResourceProvider* resource_provider, RenderPass::Id child_pass) {
33  gfx::Rect rect(0, 0, 100, 100);
34  gfx::Rect opaque_rect(10, 10, 80, 80);
35  const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
36  cc::ResourceProvider::ResourceId resource1 =
37      resource_provider->CreateResource(
38          gfx::Size(45, 5),
39          GL_CLAMP_TO_EDGE,
40          ResourceProvider::TextureUsageAny,
41          resource_provider->best_texture_format());
42  resource_provider->AllocateForTesting(resource1);
43  cc::ResourceProvider::ResourceId resource2 =
44      resource_provider->CreateResource(
45          gfx::Size(346, 61),
46          GL_CLAMP_TO_EDGE,
47          ResourceProvider::TextureUsageAny,
48          resource_provider->best_texture_format());
49  resource_provider->AllocateForTesting(resource2);
50  cc::ResourceProvider::ResourceId resource3 =
51      resource_provider->CreateResource(
52          gfx::Size(12, 134),
53          GL_CLAMP_TO_EDGE,
54          ResourceProvider::TextureUsageAny,
55          resource_provider->best_texture_format());
56  resource_provider->AllocateForTesting(resource3);
57  cc::ResourceProvider::ResourceId resource4 =
58      resource_provider->CreateResource(
59          gfx::Size(56, 12),
60          GL_CLAMP_TO_EDGE,
61          ResourceProvider::TextureUsageAny,
62          resource_provider->best_texture_format());
63  resource_provider->AllocateForTesting(resource4);
64  cc::ResourceProvider::ResourceId resource5 =
65      resource_provider->CreateResource(
66          gfx::Size(73, 26),
67          GL_CLAMP_TO_EDGE,
68          ResourceProvider::TextureUsageAny,
69          resource_provider->best_texture_format());
70  resource_provider->AllocateForTesting(resource5);
71  cc::ResourceProvider::ResourceId resource6 =
72      resource_provider->CreateResource(
73          gfx::Size(64, 92),
74          GL_CLAMP_TO_EDGE,
75          ResourceProvider::TextureUsageAny,
76          resource_provider->best_texture_format());
77  resource_provider->AllocateForTesting(resource6);
78  cc::ResourceProvider::ResourceId resource7 =
79      resource_provider->CreateResource(
80          gfx::Size(9, 14),
81          GL_CLAMP_TO_EDGE,
82          ResourceProvider::TextureUsageAny,
83          resource_provider->best_texture_format());
84  resource_provider->AllocateForTesting(resource7);
85
86  scoped_ptr<cc::SharedQuadState> shared_state = cc::SharedQuadState::Create();
87  shared_state->SetAll(gfx::Transform(),
88                       rect.size(),
89                       rect,
90                       rect,
91                       false,
92                       1);
93
94  scoped_ptr<cc::CheckerboardDrawQuad> checkerboard_quad =
95      cc::CheckerboardDrawQuad::Create();
96  checkerboard_quad->SetNew(shared_state.get(),
97                            rect,
98                            SK_ColorRED);
99  AppendQuad(checkerboard_quad.PassAs<DrawQuad>());
100
101  scoped_ptr<cc::DebugBorderDrawQuad> debug_border_quad =
102      cc::DebugBorderDrawQuad::Create();
103  debug_border_quad->SetNew(shared_state.get(),
104                            rect,
105                            SK_ColorRED,
106                            1);
107  AppendQuad(debug_border_quad.PassAs<DrawQuad>());
108
109  scoped_ptr<cc::IOSurfaceDrawQuad> io_surface_quad =
110      cc::IOSurfaceDrawQuad::Create();
111  io_surface_quad->SetNew(shared_state.get(),
112                          rect,
113                          opaque_rect,
114                          gfx::Size(50, 50),
115                          resource7,
116                          cc::IOSurfaceDrawQuad::FLIPPED);
117  AppendQuad(io_surface_quad.PassAs<DrawQuad>());
118
119  if (child_pass.layer_id) {
120    scoped_ptr<cc::RenderPassDrawQuad> render_pass_quad =
121        cc::RenderPassDrawQuad::Create();
122    render_pass_quad->SetNew(shared_state.get(),
123                             rect,
124                             child_pass,
125                             false,
126                             resource5,
127                             rect,
128                             gfx::RectF(),
129                             FilterOperations(),
130                             FilterOperations());
131    AppendQuad(render_pass_quad.PassAs<DrawQuad>());
132
133    scoped_ptr<cc::RenderPassDrawQuad> render_pass_replica_quad =
134        cc::RenderPassDrawQuad::Create();
135    render_pass_replica_quad->SetNew(shared_state.get(),
136                                     rect,
137                                     child_pass,
138                                     true,
139                                     resource5,
140                                     rect,
141                                     gfx::RectF(),
142                                     FilterOperations(),
143                                     FilterOperations());
144    AppendQuad(render_pass_replica_quad.PassAs<DrawQuad>());
145  }
146
147  scoped_ptr<cc::SolidColorDrawQuad> solid_color_quad =
148      cc::SolidColorDrawQuad::Create();
149  solid_color_quad->SetNew(shared_state.get(),
150                           rect,
151                           SK_ColorRED,
152                           false);
153  AppendQuad(solid_color_quad.PassAs<DrawQuad>());
154
155  scoped_ptr<cc::StreamVideoDrawQuad> stream_video_quad =
156      cc::StreamVideoDrawQuad::Create();
157  stream_video_quad->SetNew(shared_state.get(),
158                            rect,
159                            opaque_rect,
160                            resource6,
161                            gfx::Transform());
162  AppendQuad(stream_video_quad.PassAs<DrawQuad>());
163
164  scoped_ptr<cc::TextureDrawQuad> texture_quad =
165      cc::TextureDrawQuad::Create();
166  texture_quad->SetNew(shared_state.get(),
167                       rect,
168                       opaque_rect,
169                       resource1,
170                       false,
171                       gfx::PointF(0.f, 0.f),
172                       gfx::PointF(1.f, 1.f),
173                       SK_ColorTRANSPARENT,
174                       vertex_opacity,
175                       false);
176  AppendQuad(texture_quad.PassAs<DrawQuad>());
177
178  scoped_ptr<cc::TileDrawQuad> scaled_tile_quad =
179      cc::TileDrawQuad::Create();
180  scaled_tile_quad->SetNew(shared_state.get(),
181                           rect,
182                           opaque_rect,
183                           resource2,
184                           gfx::RectF(0, 0, 50, 50),
185                           gfx::Size(50, 50),
186                           false);
187  AppendQuad(scaled_tile_quad.PassAs<DrawQuad>());
188
189  scoped_ptr<cc::SharedQuadState> transformed_state = shared_state->Copy();
190  gfx::Transform rotation;
191  rotation.Rotate(45);
192  transformed_state->content_to_target_transform =
193      transformed_state->content_to_target_transform * rotation;
194  scoped_ptr<cc::TileDrawQuad> transformed_tile_quad =
195      cc::TileDrawQuad::Create();
196  transformed_tile_quad->SetNew(transformed_state.get(),
197                                rect,
198                                opaque_rect,
199                                resource3,
200                                gfx::RectF(0, 0, 100, 100),
201                                gfx::Size(100, 100),
202                                false);
203  AppendQuad(transformed_tile_quad.PassAs<DrawQuad>());
204
205  scoped_ptr<cc::TileDrawQuad> tile_quad =
206      cc::TileDrawQuad::Create();
207  tile_quad->SetNew(shared_state.get(),
208                    rect,
209                    opaque_rect,
210                    resource4,
211                    gfx::RectF(0, 0, 100, 100),
212                    gfx::Size(100, 100),
213                    false);
214  AppendQuad(tile_quad.PassAs<DrawQuad>());
215
216  ResourceProvider::ResourceId plane_resources[4];
217  for (int i = 0; i < 4; ++i) {
218    plane_resources[i] =
219        resource_provider->CreateResource(
220            gfx::Size(20, 12),
221            GL_CLAMP_TO_EDGE,
222            ResourceProvider::TextureUsageAny,
223            resource_provider->best_texture_format());
224    resource_provider->AllocateForTesting(plane_resources[i]);
225  }
226  scoped_ptr<cc::YUVVideoDrawQuad> yuv_quad =
227      cc::YUVVideoDrawQuad::Create();
228  yuv_quad->SetNew(shared_state.get(),
229                   rect,
230                   opaque_rect,
231                   gfx::Size(100, 100),
232                   plane_resources[0],
233                   plane_resources[1],
234                   plane_resources[2],
235                   plane_resources[3]);
236  AppendQuad(yuv_quad.PassAs<DrawQuad>());
237
238  AppendSharedQuadState(transformed_state.Pass());
239  AppendSharedQuadState(shared_state.Pass());
240}
241
242}  // namespace cc
243