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
15static const int X_SIZE = 12;
16static const int Y_SIZE = 12;
17
18////////////////////////////////////////////////////////////////////////////////
19// note: this is unused
20static 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
44static 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
103static 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
117static 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
133static 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
222DEF_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