render_pass_test_common.cc revision 58537e28ecd584eab876aee8be7156509866d23a 
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          resource_provider->best_texture_format(),
40          GL_CLAMP_TO_EDGE,
41          ResourceProvider::TextureUsageAny);
42  resource_provider->AllocateForTesting(resource1);
43  cc::ResourceProvider::ResourceId resource2 =
44      resource_provider->CreateResource(
45          gfx::Size(346, 61),
46          resource_provider->best_texture_format(),
47          GL_CLAMP_TO_EDGE,
48          ResourceProvider::TextureUsageAny);
49  resource_provider->AllocateForTesting(resource2);
50  cc::ResourceProvider::ResourceId resource3 =
51      resource_provider->CreateResource(
52          gfx::Size(12, 134),
53          resource_provider->best_texture_format(),
54          GL_CLAMP_TO_EDGE,
55          ResourceProvider::TextureUsageAny);
56  resource_provider->AllocateForTesting(resource3);
57  cc::ResourceProvider::ResourceId resource4 =
58      resource_provider->CreateResource(
59          gfx::Size(56, 12),
60          resource_provider->best_texture_format(),
61          GL_CLAMP_TO_EDGE,
62          ResourceProvider::TextureUsageAny);
63  resource_provider->AllocateForTesting(resource4);
64  cc::ResourceProvider::ResourceId resource5 =
65      resource_provider->CreateResource(
66          gfx::Size(73, 26),
67          resource_provider->best_texture_format(),
68          GL_CLAMP_TO_EDGE,
69          ResourceProvider::TextureUsageAny);
70  resource_provider->AllocateForTesting(resource5);
71  cc::ResourceProvider::ResourceId resource6 =
72      resource_provider->CreateResource(
73          gfx::Size(64, 92),
74          resource_provider->best_texture_format(),
75          GL_CLAMP_TO_EDGE,
76          ResourceProvider::TextureUsageAny);
77  resource_provider->AllocateForTesting(resource6);
78  cc::ResourceProvider::ResourceId resource7 =
79      resource_provider->CreateResource(
80          gfx::Size(9, 14),
81          resource_provider->best_texture_format(),
82          GL_CLAMP_TO_EDGE,
83          ResourceProvider::TextureUsageAny);
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                             skia::RefPtr<SkImageFilter>(),
131                             FilterOperations());
132    AppendQuad(render_pass_quad.PassAs<DrawQuad>());
133
134    scoped_ptr<cc::RenderPassDrawQuad> render_pass_replica_quad =
135        cc::RenderPassDrawQuad::Create();
136    render_pass_replica_quad->SetNew(shared_state.get(),
137                                     rect,
138                                     child_pass,
139                                     true,
140                                     resource5,
141                                     rect,
142                                     gfx::RectF(),
143                                     FilterOperations(),
144                                     skia::RefPtr<SkImageFilter>(),
145                                     FilterOperations());
146    AppendQuad(render_pass_replica_quad.PassAs<DrawQuad>());
147  }
148
149  scoped_ptr<cc::SolidColorDrawQuad> solid_color_quad =
150      cc::SolidColorDrawQuad::Create();
151  solid_color_quad->SetNew(shared_state.get(),
152                           rect,
153                           SK_ColorRED,
154                           false);
155  AppendQuad(solid_color_quad.PassAs<DrawQuad>());
156
157  scoped_ptr<cc::StreamVideoDrawQuad> stream_video_quad =
158      cc::StreamVideoDrawQuad::Create();
159  stream_video_quad->SetNew(shared_state.get(),
160                            rect,
161                            opaque_rect,
162                            resource6,
163                            gfx::Transform());
164  AppendQuad(stream_video_quad.PassAs<DrawQuad>());
165
166  scoped_ptr<cc::TextureDrawQuad> texture_quad =
167      cc::TextureDrawQuad::Create();
168  texture_quad->SetNew(shared_state.get(),
169                       rect,
170                       opaque_rect,
171                       resource1,
172                       false,
173                       gfx::PointF(0.f, 0.f),
174                       gfx::PointF(1.f, 1.f),
175                       SK_ColorTRANSPARENT,
176                       vertex_opacity,
177                       false);
178  AppendQuad(texture_quad.PassAs<DrawQuad>());
179
180  scoped_ptr<cc::TileDrawQuad> scaled_tile_quad =
181      cc::TileDrawQuad::Create();
182  scaled_tile_quad->SetNew(shared_state.get(),
183                           rect,
184                           opaque_rect,
185                           resource2,
186                           gfx::RectF(0, 0, 50, 50),
187                           gfx::Size(50, 50),
188                           false);
189  AppendQuad(scaled_tile_quad.PassAs<DrawQuad>());
190
191  scoped_ptr<cc::SharedQuadState> transformed_state = shared_state->Copy();
192  gfx::Transform rotation;
193  rotation.Rotate(45);
194  transformed_state->content_to_target_transform =
195      transformed_state->content_to_target_transform * rotation;
196  scoped_ptr<cc::TileDrawQuad> transformed_tile_quad =
197      cc::TileDrawQuad::Create();
198  transformed_tile_quad->SetNew(transformed_state.get(),
199                                rect,
200                                opaque_rect,
201                                resource3,
202                                gfx::RectF(0, 0, 100, 100),
203                                gfx::Size(100, 100),
204                                false);
205  AppendQuad(transformed_tile_quad.PassAs<DrawQuad>());
206
207  scoped_ptr<cc::TileDrawQuad> tile_quad =
208      cc::TileDrawQuad::Create();
209  tile_quad->SetNew(shared_state.get(),
210                    rect,
211                    opaque_rect,
212                    resource4,
213                    gfx::RectF(0, 0, 100, 100),
214                    gfx::Size(100, 100),
215                    false);
216  AppendQuad(tile_quad.PassAs<DrawQuad>());
217
218  ResourceProvider::ResourceId plane_resources[4];
219  for (int i = 0; i < 4; ++i) {
220    plane_resources[i] =
221        resource_provider->CreateResource(
222            gfx::Size(20, 12),
223            resource_provider->best_texture_format(),
224            GL_CLAMP_TO_EDGE,
225            ResourceProvider::TextureUsageAny);
226    resource_provider->AllocateForTesting(plane_resources[i]);
227  }
228  scoped_ptr<cc::YUVVideoDrawQuad> yuv_quad =
229      cc::YUVVideoDrawQuad::Create();
230  yuv_quad->SetNew(shared_state.get(),
231                   rect,
232                   opaque_rect,
233                   gfx::Size(100, 100),
234                   plane_resources[0],
235                   plane_resources[1],
236                   plane_resources[2],
237                   plane_resources[3]);
238  AppendQuad(yuv_quad.PassAs<DrawQuad>());
239
240  AppendSharedQuadState(transformed_state.Pass());
241  AppendSharedQuadState(shared_state.Pass());
242}
243
244}  // namespace cc
245