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