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