1
2/*
3 * Copyright 2013 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8#include "gm.h"
9#include "SkBitmap.h"
10#include "SkGradientShader.h"
11#include "SkXfermode.h"
12#include "SkColorPriv.h"
13
14#if SK_SUPPORT_GPU
15#include "GrContext.h"
16#include "SkGpuDevice.h"
17#endif
18
19namespace skiagm {
20
21/**
22 * This tests drawing device-covering rects with solid colors and bitmap shaders over a
23 * checkerboard background using different xfermodes.
24 */
25class Xfermodes3GM : public GM {
26public:
27    Xfermodes3GM() {}
28
29protected:
30    virtual SkString onShortName() SK_OVERRIDE {
31        return SkString("xfermodes3");
32    }
33
34    virtual SkISize onISize() SK_OVERRIDE {
35        return SkISize::Make(630, 1215);
36    }
37
38    virtual void onDrawBackground(SkCanvas* canvas) SK_OVERRIDE {
39        SkPaint bgPaint;
40        bgPaint.setColor(0xFF70D0E0);
41        canvas->drawPaint(bgPaint);
42    }
43
44    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
45        canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
46
47        SkPaint labelP;
48        labelP.setAntiAlias(true);
49
50        static const SkColor kSolidColors[] = {
51            SK_ColorTRANSPARENT,
52            SK_ColorBLUE,
53            0x80808000
54        };
55
56        static const SkColor kBmpAlphas[] = {
57            0xff,
58            0x80,
59        };
60
61        SkAutoTUnref<SkCanvas> tempCanvas(this->possiblyCreateTempCanvas(canvas, kSize, kSize));
62
63        int test = 0;
64        int x = 0, y = 0;
65        static const struct { SkPaint::Style fStyle; SkScalar fWidth; } kStrokes[] = {
66            {SkPaint::kFill_Style, 0},
67            {SkPaint::kStroke_Style, SkIntToScalar(kSize) / 2},
68        };
69        for (size_t s = 0; s < SK_ARRAY_COUNT(kStrokes); ++s) {
70            for (size_t m = 0; m <= SkXfermode::kLastMode; ++m) {
71                SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(m);
72                canvas->drawText(SkXfermode::ModeName(mode),
73                                 strlen(SkXfermode::ModeName(mode)),
74                                 SkIntToScalar(x),
75                                 SkIntToScalar(y + kSize + 3) + labelP.getTextSize(),
76                                 labelP);
77                for (size_t c = 0; c < SK_ARRAY_COUNT(kSolidColors); ++c) {
78                    SkPaint modePaint;
79                    modePaint.setXfermodeMode(mode);
80                    modePaint.setColor(kSolidColors[c]);
81                    modePaint.setStyle(kStrokes[s].fStyle);
82                    modePaint.setStrokeWidth(kStrokes[s].fWidth);
83
84                    this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempCanvas.get());
85
86                    ++test;
87                    x += kSize + 10;
88                    if (!(test % kTestsPerRow)) {
89                        x = 0;
90                        y += kSize + 30;
91                    }
92                }
93                for (size_t a = 0; a < SK_ARRAY_COUNT(kBmpAlphas); ++a) {
94                    SkPaint modePaint;
95                    modePaint.setXfermodeMode(mode);
96                    modePaint.setAlpha(kBmpAlphas[a]);
97                    modePaint.setShader(fBmpShader);
98                    modePaint.setStyle(kStrokes[s].fStyle);
99                    modePaint.setStrokeWidth(kStrokes[s].fWidth);
100
101                    this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempCanvas.get());
102
103                    ++test;
104                    x += kSize + 10;
105                    if (!(test % kTestsPerRow)) {
106                        x = 0;
107                        y += kSize + 30;
108                    }
109                }
110            }
111        }
112    }
113
114private:
115    /**
116     * GrContext has optimizations around full rendertarget draws that can be replaced with clears.
117     * We are trying to test those. We could use saveLayer() to create small SkGpuDevices but
118     * saveLayer() uses the texture cache. This means that the actual render target may be larger
119     * than the layer. Because the clip will contain the layer's bounds, no draws will be full-RT.
120     * So when running on a GPU canvas we explicitly create a temporary canvas using a texture with
121     * dimensions exactly matching the layer size.
122     */
123    SkCanvas* possiblyCreateTempCanvas(SkCanvas* baseCanvas, int w, int h) {
124        SkCanvas* tempCanvas = NULL;
125#if SK_SUPPORT_GPU
126        GrRenderTarget* rt = baseCanvas->getDevice()->accessRenderTarget();
127        if (NULL != rt) {
128            GrContext* context = rt->getContext();
129            GrTextureDesc desc;
130            desc.fWidth = w;
131            desc.fHeight = h;
132            desc.fConfig = rt->config();
133            desc.fFlags = kRenderTarget_GrTextureFlagBit;
134            SkAutoTUnref<GrSurface> surface(context->createUncachedTexture(desc, NULL, 0));
135            SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(surface.get()));
136            if (NULL != device.get()) {
137                tempCanvas = SkNEW_ARGS(SkCanvas, (device.get()));
138            }
139        }
140#endif
141        return tempCanvas;
142    }
143
144    void drawMode(SkCanvas* canvas,
145                  int x, int y, int w, int h,
146                  const SkPaint& modePaint, SkCanvas* layerCanvas) {
147        canvas->save();
148
149        canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
150
151        SkRect r = SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h));
152
153        SkCanvas* modeCanvas;
154        if (NULL == layerCanvas) {
155            canvas->saveLayer(&r, NULL);
156            modeCanvas = canvas;
157        } else {
158            modeCanvas = layerCanvas;
159        }
160
161        SkPaint bgPaint;
162        bgPaint.setAntiAlias(false);
163        bgPaint.setShader(fBGShader);
164        modeCanvas->drawRect(r, bgPaint);
165        modeCanvas->drawRect(r, modePaint);
166        modeCanvas = NULL;
167
168        if (NULL == layerCanvas) {
169            canvas->restore();
170        } else {
171            SkAutoROCanvasPixels ropixels(layerCanvas);
172            SkBitmap bitmap;
173            if (ropixels.asROBitmap(&bitmap)) {
174                canvas->drawBitmap(bitmap, 0, 0);
175            }
176        }
177
178        r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
179        SkPaint borderPaint;
180        borderPaint.setStyle(SkPaint::kStroke_Style);
181        canvas->drawRect(r, borderPaint);
182
183        canvas->restore();
184    }
185
186    virtual void onOnceBeforeDraw() SK_OVERRIDE {
187        static const uint32_t kCheckData[] = {
188            SkPackARGB32(0xFF, 0x40, 0x40, 0x40),
189            SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
190            SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
191            SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
192        };
193        SkBitmap bg;
194        bg.allocN32Pixels(2, 2, true);
195        SkAutoLockPixels bgAlp(bg);
196        memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
197
198        SkMatrix lm;
199        lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
200        fBGShader.reset(SkShader::CreateBitmapShader(bg,
201                                                     SkShader::kRepeat_TileMode,
202                                                     SkShader::kRepeat_TileMode,
203                                                     &lm));
204
205        SkPaint bmpPaint;
206        static const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };
207        static const SkColor kColors[] = { SK_ColorTRANSPARENT, 0x80800000,
208                                          0xF020F060, SK_ColorWHITE };
209        bmpPaint.setShader(SkGradientShader::CreateRadial(kCenter,
210                                                          3 * SkIntToScalar(kSize) / 4,
211                                                          kColors,
212                                                          NULL,
213                                                          SK_ARRAY_COUNT(kColors),
214                                                          SkShader::kRepeat_TileMode))->unref();
215
216        SkBitmap bmp;
217        bmp.allocN32Pixels(kSize, kSize);
218        SkCanvas bmpCanvas(bmp);
219
220        bmpCanvas.clear(SK_ColorTRANSPARENT);
221        SkRect rect = { SkIntToScalar(kSize) / 8, SkIntToScalar(kSize) / 8,
222                        7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8};
223        bmpCanvas.drawRect(rect, bmpPaint);
224
225        fBmpShader.reset(SkShader::CreateBitmapShader(bmp,
226                                                      SkShader::kClamp_TileMode,
227                                                      SkShader::kClamp_TileMode));
228    }
229
230    enum {
231        kCheckSize = 8,
232        kSize = 30,
233        kTestsPerRow = 15,
234    };
235
236    SkAutoTUnref<SkShader> fBGShader;
237    SkAutoTUnref<SkShader> fBmpShader;
238
239    typedef GM INHERITED;
240};
241
242//////////////////////////////////////////////////////////////////////////////
243
244DEF_GM(return new Xfermodes3GM;)
245
246}
247