1 /*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "Test.h"
9 // This is a GR test
10 #if SK_SUPPORT_GPU
11 #include "../../src/gpu/GrClipMaskManager.h"
12 #include "GrContextFactory.h"
13 #include "SkGpuDevice.h"
14
15 static const int X_SIZE = 12;
16 static const int Y_SIZE = 12;
17
18 ////////////////////////////////////////////////////////////////////////////////
19 // note: this is unused
createTexture(GrContext * context)20 static GrTexture* createTexture(GrContext* context) {
21 unsigned char textureData[X_SIZE][Y_SIZE][4];
22
23 memset(textureData, 0, 4* X_SIZE * Y_SIZE);
24
25 GrTextureDesc desc;
26
27 // let Skia know we will be using this texture as a render target
28 desc.fFlags = kRenderTarget_GrTextureFlagBit;
29 desc.fConfig = kSkia8888_GrPixelConfig;
30 desc.fWidth = X_SIZE;
31 desc.fHeight = Y_SIZE;
32
33 // We are initializing the texture with zeros here
34 GrTexture* texture = context->createUncachedTexture(desc, textureData, 0);
35 if (!texture) {
36 return NULL;
37 }
38
39 return texture;
40 }
41
42 // Ensure that the 'getConservativeBounds' calls are returning bounds clamped
43 // to the render target
test_clip_bounds(skiatest::Reporter * reporter,GrContext * context)44 static void test_clip_bounds(skiatest::Reporter* reporter, GrContext* context) {
45
46 static const int kXSize = 100;
47 static const int kYSize = 100;
48
49 GrTextureDesc desc;
50 desc.fFlags = kRenderTarget_GrTextureFlagBit;
51 desc.fConfig = kAlpha_8_GrPixelConfig;
52 desc.fWidth = kXSize;
53 desc.fHeight = kYSize;
54
55 GrTexture* texture = context->createUncachedTexture(desc, NULL, 0);
56 if (!texture) {
57 return;
58 }
59
60 SkAutoUnref au(texture);
61
62 SkIRect intScreen = SkIRect::MakeWH(kXSize, kYSize);
63 SkRect screen;
64
65 screen = SkRect::MakeWH(SkIntToScalar(kXSize),
66 SkIntToScalar(kYSize));
67
68 SkRect clipRect(screen);
69 clipRect.outset(10, 10);
70
71 // create a clip stack that will (trivially) reduce to a single rect that
72 // is larger than the screen
73 SkClipStack stack;
74 stack.clipDevRect(clipRect, SkRegion::kReplace_Op, false);
75
76 bool isIntersectionOfRects = true;
77 SkRect devStackBounds;
78
79 stack.getConservativeBounds(0, 0, kXSize, kYSize,
80 &devStackBounds,
81 &isIntersectionOfRects);
82
83 // make sure that the SkClipStack is behaving itself
84 REPORTER_ASSERT(reporter, screen == devStackBounds);
85 REPORTER_ASSERT(reporter, isIntersectionOfRects);
86
87 // wrap the SkClipStack in a GrClipData
88 GrClipData clipData;
89 clipData.fClipStack = &stack;
90
91 SkIRect devGrClipDataBound;
92 clipData.getConservativeBounds(texture,
93 &devGrClipDataBound,
94 &isIntersectionOfRects);
95
96 // make sure that GrClipData is behaving itself
97 REPORTER_ASSERT(reporter, intScreen == devGrClipDataBound);
98 REPORTER_ASSERT(reporter, isIntersectionOfRects);
99 }
100
101 ////////////////////////////////////////////////////////////////////////////////
102 // verify that the top state of the stack matches the passed in state
check_state(skiatest::Reporter * reporter,const GrClipMaskCache & cache,const SkClipStack & clip,GrTexture * mask,const SkIRect & bound)103 static void check_state(skiatest::Reporter* reporter,
104 const GrClipMaskCache& cache,
105 const SkClipStack& clip,
106 GrTexture* mask,
107 const SkIRect& bound) {
108 REPORTER_ASSERT(reporter, clip.getTopmostGenID() == cache.getLastClipGenID());
109
110 REPORTER_ASSERT(reporter, mask == cache.getLastMask());
111
112 SkIRect cacheBound;
113 cache.getLastBound(&cacheBound);
114 REPORTER_ASSERT(reporter, bound == cacheBound);
115 }
116
check_empty_state(skiatest::Reporter * reporter,const GrClipMaskCache & cache)117 static void check_empty_state(skiatest::Reporter* reporter,
118 const GrClipMaskCache& cache) {
119 REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID == cache.getLastClipGenID());
120 REPORTER_ASSERT(reporter, NULL == cache.getLastMask());
121
122 SkIRect emptyBound;
123 emptyBound.setEmpty();
124
125 SkIRect cacheBound;
126 cache.getLastBound(&cacheBound);
127 REPORTER_ASSERT(reporter, emptyBound == cacheBound);
128 }
129
130 ////////////////////////////////////////////////////////////////////////////////
131 // basic test of the cache's base functionality:
132 // push, pop, set, canReuse & getters
test_cache(skiatest::Reporter * reporter,GrContext * context)133 static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
134
135 if (false) { // avoid bit rot, suppress warning
136 createTexture(context);
137 }
138 GrClipMaskCache cache;
139
140 cache.setContext(context);
141
142 // check initial state
143 check_empty_state(reporter, cache);
144
145 // set the current state
146 SkIRect bound1;
147 bound1.set(0, 0, 100, 100);
148
149 SkClipStack clip1(bound1);
150
151 GrTextureDesc desc;
152 desc.fFlags = kRenderTarget_GrTextureFlagBit;
153 desc.fWidth = X_SIZE;
154 desc.fHeight = Y_SIZE;
155 desc.fConfig = kSkia8888_GrPixelConfig;
156
157 cache.acquireMask(clip1.getTopmostGenID(), desc, bound1);
158
159 GrTexture* texture1 = cache.getLastMask();
160 REPORTER_ASSERT(reporter, texture1);
161 if (NULL == texture1) {
162 return;
163 }
164
165 // check that the set took
166 check_state(reporter, cache, clip1, texture1, bound1);
167 REPORTER_ASSERT(reporter, texture1->getRefCnt());
168
169 // push the state
170 cache.push();
171
172 // verify that the pushed state is initially empty
173 check_empty_state(reporter, cache);
174 REPORTER_ASSERT(reporter, texture1->getRefCnt());
175
176 // modify the new state
177 SkIRect bound2;
178 bound2.set(-10, -10, 10, 10);
179
180 SkClipStack clip2(bound2);
181
182 cache.acquireMask(clip2.getTopmostGenID(), desc, bound2);
183
184 GrTexture* texture2 = cache.getLastMask();
185 REPORTER_ASSERT(reporter, texture2);
186 if (NULL == texture2) {
187 return;
188 }
189
190 // check that the changes took
191 check_state(reporter, cache, clip2, texture2, bound2);
192 REPORTER_ASSERT(reporter, texture1->getRefCnt());
193 REPORTER_ASSERT(reporter, texture2->getRefCnt());
194
195 // check to make sure canReuse works
196 REPORTER_ASSERT(reporter, cache.canReuse(clip2.getTopmostGenID(), bound2));
197 REPORTER_ASSERT(reporter, !cache.canReuse(clip1.getTopmostGenID(), bound1));
198
199 // pop the state
200 cache.pop();
201
202 // verify that the old state is restored
203 check_state(reporter, cache, clip1, texture1, bound1);
204 REPORTER_ASSERT(reporter, texture1->getRefCnt());
205
206 // manually clear the state
207 cache.reset();
208
209 // verify it is now empty
210 check_empty_state(reporter, cache);
211
212 // pop again - so there is no state
213 cache.pop();
214
215 #if !defined(SK_DEBUG)
216 // verify that the getters don't crash
217 // only do in release since it generates asserts in debug
218 check_empty_state(reporter, cache);
219 #endif
220 }
221
DEF_GPUTEST(ClipCache,reporter,factory)222 DEF_GPUTEST(ClipCache, reporter, factory) {
223 for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
224 GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
225 if (!GrContextFactory::IsRenderingGLContext(glType)) {
226 continue;
227 }
228 GrContext* context = factory->get(glType);
229 if (NULL == context) {
230 continue;
231 }
232
233 test_cache(reporter, context);
234 test_clip_bounds(reporter, context);
235 }
236 }
237
238 #endif
239