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