1
2/*
3 * Copyright 2011 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 "SkCanvas.h"
10#include "SkGradientShader.h"
11#include "SkGraphics.h"
12#include "SkPath.h"
13#include "SkRegion.h"
14#include "SkShader.h"
15
16static void make_bitmap(SkBitmap* bitmap) {
17    bitmap->allocN32Pixels(64, 64);
18
19    SkCanvas canvas(*bitmap);
20
21    canvas.drawColor(SK_ColorRED);
22    SkPaint paint;
23    paint.setAntiAlias(true);
24    const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
25    const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
26    paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
27                                                   SkShader::kClamp_TileMode))->unref();
28    canvas.drawCircle(32, 32, 32, paint);
29}
30
31class DrawBitmapRect2 : public skiagm::GM {
32    bool fUseIRect;
33public:
34    DrawBitmapRect2(bool useIRect) : fUseIRect(useIRect) {
35    }
36
37protected:
38    SkString onShortName() override {
39        SkString str;
40        str.printf("bitmaprect_%s", fUseIRect ? "i" : "s");
41        return str;
42    }
43
44    SkISize onISize() override {
45        return SkISize::Make(640, 480);
46    }
47
48    void onDraw(SkCanvas* canvas) override {
49        canvas->drawColor(0xFFCCCCCC);
50
51        const SkIRect src[] = {
52            { 0, 0, 32, 32 },
53            { 0, 0, 80, 80 },
54            { 32, 32, 96, 96 },
55            { -32, -32, 32, 32, }
56        };
57
58        SkPaint paint;
59        paint.setStyle(SkPaint::kStroke_Style);
60
61        SkBitmap bitmap;
62        make_bitmap(&bitmap);
63
64        SkRect dstR = { 0, 200, 128, 380 };
65
66        canvas->translate(16, 40);
67        for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
68            SkRect srcR;
69            srcR.set(src[i]);
70
71            canvas->drawBitmap(bitmap, 0, 0, &paint);
72            if (!fUseIRect) {
73                canvas->drawBitmapRectToRect(bitmap, &srcR, dstR, &paint);
74            } else {
75                canvas->drawBitmapRect(bitmap, &src[i], dstR, &paint);
76            }
77
78            canvas->drawRect(dstR, paint);
79            canvas->drawRect(srcR, paint);
80
81            canvas->translate(160, 0);
82        }
83    }
84
85private:
86    typedef skiagm::GM INHERITED;
87};
88
89//////////////////////////////////////////////////////////////////////////////
90
91static void make_3x3_bitmap(SkBitmap* bitmap) {
92    const int xSize = 3;
93    const int ySize = 3;
94
95    const SkColor textureData[xSize][ySize] = {
96        { SK_ColorRED,    SK_ColorWHITE, SK_ColorBLUE },
97        { SK_ColorGREEN,  SK_ColorBLACK, SK_ColorCYAN },
98        { SK_ColorYELLOW, SK_ColorGRAY,  SK_ColorMAGENTA }
99    };
100
101    bitmap->allocN32Pixels(xSize, ySize, true);
102    SkCanvas canvas(*bitmap);
103    SkPaint paint;
104
105    for (int y = 0; y < ySize; y++) {
106        for (int x = 0; x < xSize; x++) {
107            paint.setColor(textureData[x][y]);
108            canvas.drawIRect(SkIRect::MakeXYWH(x, y, 1, 1), paint);
109        }
110    }
111}
112
113// This GM attempts to make visible any issues drawBitmapRectToRect may have
114// with partial source rects. In this case the eight pixels on the border
115// should be half the width/height of the central pixel, i.e.:
116//                         __|____|__
117//                           |    |
118//                         __|____|__
119//                           |    |
120class DrawBitmapRect3 : public skiagm::GM {
121public:
122    DrawBitmapRect3() {
123        this->setBGColor(SK_ColorBLACK);
124    }
125
126protected:
127    SkString onShortName() override {
128        SkString str;
129        str.printf("3x3bitmaprect");
130        return str;
131    }
132
133    SkISize onISize() override {
134        return SkISize::Make(640, 480);
135    }
136
137    void onDraw(SkCanvas* canvas) override {
138
139        SkBitmap bitmap;
140        make_3x3_bitmap(&bitmap);
141
142        SkRect srcR = { 0.5f, 0.5f, 2.5f, 2.5f };
143        SkRect dstR = { 100, 100, 300, 200 };
144
145        canvas->drawBitmapRectToRect(bitmap, &srcR, dstR, NULL);
146    }
147
148private:
149    typedef skiagm::GM INHERITED;
150};
151
152//////////////////////////////////////////////////////////////////////////////
153static void make_big_bitmap(SkBitmap* bitmap) {
154
155    static const int gXSize = 4096;
156    static const int gYSize = 4096;
157    static const int gBorderWidth = 10;
158
159    bitmap->allocN32Pixels(gXSize, gYSize);
160    for (int y = 0; y < gYSize; ++y) {
161        for (int x = 0; x < gXSize; ++x) {
162            if (x <= gBorderWidth || x >= gXSize-gBorderWidth ||
163                y <= gBorderWidth || y >= gYSize-gBorderWidth) {
164                *bitmap->getAddr32(x, y) = SkPreMultiplyColor(0x88FFFFFF);
165            } else {
166                *bitmap->getAddr32(x, y) = SkPreMultiplyColor(0x88FF0000);
167            }
168        }
169    }
170}
171
172// This GM attempts to reveal any issues we may have when the GPU has to
173// break up a large texture in order to draw it. The XOR transfer mode will
174// create stripes in the image if there is imprecision in the destination
175// tile placement.
176class DrawBitmapRect4 : public skiagm::GM {
177    bool fUseIRect;
178    SkBitmap fBigBitmap;
179
180public:
181    DrawBitmapRect4(bool useIRect) : fUseIRect(useIRect) {
182        this->setBGColor(0x88444444);
183    }
184
185protected:
186    SkString onShortName() override {
187        SkString str;
188        str.printf("bigbitmaprect_%s", fUseIRect ? "i" : "s");
189        return str;
190    }
191
192    SkISize onISize() override {
193        return SkISize::Make(640, 480);
194    }
195
196    void onOnceBeforeDraw() override {
197        make_big_bitmap(&fBigBitmap);
198    }
199
200    void onDraw(SkCanvas* canvas) override {
201
202        SkXfermode* mode = SkXfermode::Create(SkXfermode::kXor_Mode);
203
204        SkPaint paint;
205        paint.setAlpha(128);
206        paint.setXfermode(mode)->unref();
207
208        SkRect srcR1 = { 0.0f, 0.0f, 4096.0f, 2040.0f };
209        SkRect dstR1 = { 10.1f, 10.1f, 629.9f, 400.9f };
210
211        SkRect srcR2 = { 4085.0f, 10.0f, 4087.0f, 12.0f };
212        SkRect dstR2 = { 10, 410, 30, 430 };
213
214        if (!fUseIRect) {
215            canvas->drawBitmapRectToRect(fBigBitmap, &srcR1, dstR1, &paint);
216            canvas->drawBitmapRectToRect(fBigBitmap, &srcR2, dstR2, &paint);
217        } else {
218            SkIRect iSrcR1, iSrcR2;
219
220            srcR1.roundOut(&iSrcR1);
221            srcR2.roundOut(&iSrcR2);
222
223            canvas->drawBitmapRect(fBigBitmap, &iSrcR1, dstR1, &paint);
224            canvas->drawBitmapRect(fBigBitmap, &iSrcR2, dstR2, &paint);
225        }
226    }
227
228private:
229    typedef skiagm::GM INHERITED;
230};
231
232class BitmapRectRounding : public skiagm::GM {
233    SkBitmap fBM;
234
235public:
236    BitmapRectRounding() {}
237
238protected:
239    SkString onShortName() override {
240        SkString str;
241        str.printf("bitmaprect_rounding");
242        return str;
243    }
244
245    SkISize onISize() override {
246        return SkISize::Make(640, 480);
247    }
248
249    void onOnceBeforeDraw() override {
250        fBM.allocN32Pixels(10, 10);
251        fBM.eraseColor(SK_ColorBLUE);
252    }
253
254    // This choice of coordinates and matrix land the bottom edge of the clip (and bitmap dst)
255    // at exactly 1/2 pixel boundary. However, drawBitmapRect may lose precision along the way.
256    // If it does, we may see a red-line at the bottom, instead of the bitmap exactly matching
257    // the clip (in which case we should see all blue).
258    // The correct image should be all blue.
259    void onDraw(SkCanvas* canvas) override {
260        SkPaint paint;
261        paint.setColor(SK_ColorRED);
262
263        const SkRect r = SkRect::MakeXYWH(1, 1, 110, 114);
264        canvas->scale(0.9f, 0.9f);
265
266        // the drawRect shows the same problem as clipRect(r) followed by drawcolor(red)
267        canvas->drawRect(r, paint);
268        canvas->drawBitmapRect(fBM, NULL, r, NULL);
269    }
270
271private:
272    typedef skiagm::GM INHERITED;
273};
274DEF_GM( return new BitmapRectRounding; )
275
276//////////////////////////////////////////////////////////////////////////////
277
278static skiagm::GM* MyFactory0(void*) { return new DrawBitmapRect2(false); }
279static skiagm::GM* MyFactory1(void*) { return new DrawBitmapRect2(true); }
280
281static skiagm::GM* MyFactory2(void*) { return new DrawBitmapRect3(); }
282
283#ifndef SK_BUILD_FOR_ANDROID
284static skiagm::GM* MyFactory3(void*) { return new DrawBitmapRect4(false); }
285static skiagm::GM* MyFactory4(void*) { return new DrawBitmapRect4(true); }
286#endif
287
288static skiagm::GMRegistry reg0(MyFactory0);
289static skiagm::GMRegistry reg1(MyFactory1);
290
291static skiagm::GMRegistry reg2(MyFactory2);
292
293#ifndef SK_BUILD_FOR_ANDROID
294static skiagm::GMRegistry reg3(MyFactory3);
295static skiagm::GMRegistry reg4(MyFactory4);
296#endif
297
298