drawbitmaprect.cpp 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255
  1. /*
  2. * Copyright 2011 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. #include "gm/gm.h"
  8. #include "include/core/SkBitmap.h"
  9. #include "include/core/SkBlurTypes.h"
  10. #include "include/core/SkCanvas.h"
  11. #include "include/core/SkColor.h"
  12. #include "include/core/SkFilterQuality.h"
  13. #include "include/core/SkFont.h"
  14. #include "include/core/SkImage.h"
  15. #include "include/core/SkImageInfo.h"
  16. #include "include/core/SkMaskFilter.h"
  17. #include "include/core/SkMatrix.h"
  18. #include "include/core/SkPaint.h"
  19. #include "include/core/SkPoint.h"
  20. #include "include/core/SkRect.h"
  21. #include "include/core/SkRefCnt.h"
  22. #include "include/core/SkScalar.h"
  23. #include "include/core/SkShader.h"
  24. #include "include/core/SkSize.h"
  25. #include "include/core/SkString.h"
  26. #include "include/core/SkSurface.h"
  27. #include "include/core/SkTileMode.h"
  28. #include "include/core/SkTypeface.h"
  29. #include "include/core/SkTypes.h"
  30. #include "include/effects/SkGradientShader.h"
  31. #include "src/core/SkBlurMask.h"
  32. #include "src/core/SkMathPriv.h"
  33. #include "tools/ToolUtils.h"
  34. static SkBitmap make_chessbm(int w, int h) {
  35. SkBitmap bm;
  36. bm.allocN32Pixels(w, h);
  37. for (int y = 0; y < bm.height(); y++) {
  38. uint32_t* p = bm.getAddr32(0, y);
  39. for (int x = 0; x < bm.width(); x++) {
  40. p[x] = ((x + y) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
  41. }
  42. }
  43. return bm;
  44. }
  45. // Creates a bitmap and a matching image.
  46. static sk_sp<SkImage> makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) {
  47. SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
  48. auto surface(ToolUtils::makeSurface(origCanvas, info));
  49. SkCanvas* canvas = surface->getCanvas();
  50. canvas->clear(SK_ColorTRANSPARENT);
  51. SkScalar wScalar = SkIntToScalar(w);
  52. SkScalar hScalar = SkIntToScalar(h);
  53. SkPoint pt = { wScalar / 2, hScalar / 2 };
  54. SkScalar radius = 4 * SkMaxScalar(wScalar, hScalar);
  55. SkColor colors[] = { SK_ColorRED, SK_ColorYELLOW,
  56. SK_ColorGREEN, SK_ColorMAGENTA,
  57. SK_ColorBLUE, SK_ColorCYAN,
  58. SK_ColorRED};
  59. SkScalar pos[] = {0,
  60. SK_Scalar1 / 6,
  61. 2 * SK_Scalar1 / 6,
  62. 3 * SK_Scalar1 / 6,
  63. 4 * SK_Scalar1 / 6,
  64. 5 * SK_Scalar1 / 6,
  65. SK_Scalar1};
  66. SkPaint paint;
  67. SkRect rect = SkRect::MakeWH(wScalar, hScalar);
  68. SkMatrix mat = SkMatrix::I();
  69. for (int i = 0; i < 4; ++i) {
  70. paint.setShader(SkGradientShader::MakeRadial(
  71. pt, radius,
  72. colors, pos,
  73. SK_ARRAY_COUNT(colors),
  74. SkTileMode::kRepeat,
  75. 0, &mat));
  76. canvas->drawRect(rect, paint);
  77. rect.inset(wScalar / 8, hScalar / 8);
  78. mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
  79. }
  80. auto image = surface->makeImageSnapshot();
  81. SkBitmap tempBM;
  82. image->asLegacyBitmap(&tempBM);
  83. // Let backends know we won't change this, so they don't have to deep copy it defensively.
  84. tempBM.setImmutable();
  85. *resultBM = tempBM;
  86. return image;
  87. }
  88. static void bitmapproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
  89. const SkRect& dstR, const SkPaint* paint) {
  90. canvas->drawBitmapRect(bm, srcR, dstR, paint);
  91. }
  92. static void bitmapsubsetproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
  93. const SkRect& dstR, const SkPaint* paint) {
  94. if (!bm.bounds().contains(srcR)) {
  95. bitmapproc(canvas, nullptr, bm, srcR, dstR, paint);
  96. return;
  97. }
  98. SkBitmap subset;
  99. if (bm.extractSubset(&subset, srcR)) {
  100. canvas->drawBitmapRect(subset, dstR, paint);
  101. }
  102. }
  103. static void imageproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect& srcR,
  104. const SkRect& dstR, const SkPaint* paint) {
  105. canvas->drawImageRect(image, srcR, dstR, paint);
  106. }
  107. static void imagesubsetproc(SkCanvas* canvas, SkImage* image, const SkBitmap& bm,
  108. const SkIRect& srcR, const SkRect& dstR, const SkPaint* paint) {
  109. if (!image->bounds().contains(srcR)) {
  110. imageproc(canvas, image, bm, srcR, dstR, paint);
  111. return;
  112. }
  113. if (sk_sp<SkImage> subset = image->makeSubset(srcR)) {
  114. canvas->drawImageRect(subset, dstR, paint);
  115. }
  116. }
  117. typedef void DrawRectRectProc(SkCanvas*, SkImage*, const SkBitmap&, const SkIRect&, const SkRect&,
  118. const SkPaint*);
  119. constexpr int gSize = 1024;
  120. constexpr int gBmpSize = 2048;
  121. class DrawBitmapRectGM : public skiagm::GM {
  122. public:
  123. DrawBitmapRectGM(DrawRectRectProc proc, const char suffix[]) : fProc(proc) {
  124. fName.set("drawbitmaprect");
  125. if (suffix) {
  126. fName.append(suffix);
  127. }
  128. }
  129. DrawRectRectProc* fProc;
  130. SkBitmap fLargeBitmap;
  131. sk_sp<SkImage> fImage;
  132. SkString fName;
  133. protected:
  134. SkString onShortName() override { return fName; }
  135. SkISize onISize() override { return SkISize::Make(gSize, gSize); }
  136. void setupImage(SkCanvas* canvas) {
  137. fImage = makebm(canvas, &fLargeBitmap, gBmpSize, gBmpSize);
  138. }
  139. void onDraw(SkCanvas* canvas) override {
  140. if (!fImage || !fImage->isValid(canvas->getGrContext())) {
  141. this->setupImage(canvas);
  142. }
  143. SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)};
  144. const int kMaxSrcRectSize = 1 << (SkNextLog2(gBmpSize) + 2);
  145. const int kPadX = 30;
  146. const int kPadY = 40;
  147. SkPaint paint;
  148. paint.setAlphaf(0.125f);
  149. canvas->drawImageRect(fImage, SkRect::MakeIWH(gSize, gSize), &paint);
  150. canvas->translate(SK_Scalar1 * kPadX / 2,
  151. SK_Scalar1 * kPadY / 2);
  152. SkPaint blackPaint;
  153. SkScalar titleHeight = SK_Scalar1 * 24;
  154. blackPaint.setColor(SK_ColorBLACK);
  155. blackPaint.setAntiAlias(true);
  156. SkFont font(ToolUtils::create_portable_typeface(), titleHeight);
  157. SkString title;
  158. title.printf("Bitmap size: %d x %d", gBmpSize, gBmpSize);
  159. canvas->drawString(title, 0, titleHeight, font, blackPaint);
  160. canvas->translate(0, SK_Scalar1 * kPadY / 2 + titleHeight);
  161. int rowCount = 0;
  162. canvas->save();
  163. for (int w = 1; w <= kMaxSrcRectSize; w *= 4) {
  164. for (int h = 1; h <= kMaxSrcRectSize; h *= 4) {
  165. SkIRect srcRect = SkIRect::MakeXYWH((gBmpSize - w) / 2, (gBmpSize - h) / 2, w, h);
  166. fProc(canvas, fImage.get(), fLargeBitmap, srcRect, dstRect, nullptr);
  167. SkString label;
  168. label.appendf("%d x %d", w, h);
  169. blackPaint.setAntiAlias(true);
  170. blackPaint.setStyle(SkPaint::kFill_Style);
  171. font.setSize(SK_Scalar1 * 10);
  172. SkScalar baseline = dstRect.height() + font.getSize() + SK_Scalar1 * 3;
  173. canvas->drawString(label, 0, baseline, font, blackPaint);
  174. blackPaint.setStyle(SkPaint::kStroke_Style);
  175. blackPaint.setStrokeWidth(SK_Scalar1);
  176. blackPaint.setAntiAlias(false);
  177. canvas->drawRect(dstRect, blackPaint);
  178. canvas->translate(dstRect.width() + SK_Scalar1 * kPadX, 0);
  179. ++rowCount;
  180. if ((dstRect.width() + kPadX) * rowCount > gSize) {
  181. canvas->restore();
  182. canvas->translate(0, dstRect.height() + SK_Scalar1 * kPadY);
  183. canvas->save();
  184. rowCount = 0;
  185. }
  186. }
  187. }
  188. {
  189. // test the following code path:
  190. // SkGpuDevice::drawPath() -> SkGpuDevice::drawWithMaskFilter()
  191. SkIRect srcRect;
  192. SkPaint paint;
  193. SkBitmap bm;
  194. bm = make_chessbm(5, 5);
  195. paint.setFilterQuality(kLow_SkFilterQuality);
  196. srcRect.setXYWH(1, 1, 3, 3);
  197. paint.setMaskFilter(SkMaskFilter::MakeBlur(
  198. kNormal_SkBlurStyle,
  199. SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5))));
  200. sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
  201. fProc(canvas, image.get(), bm, srcRect, dstRect, &paint);
  202. }
  203. }
  204. private:
  205. typedef skiagm::GM INHERITED;
  206. };
  207. DEF_GM( return new DrawBitmapRectGM(bitmapproc , nullptr); )
  208. DEF_GM( return new DrawBitmapRectGM(bitmapsubsetproc, "-subset"); )
  209. DEF_GM( return new DrawBitmapRectGM(imageproc , "-imagerect"); )
  210. DEF_GM( return new DrawBitmapRectGM(imagesubsetproc , "-imagerect-subset"); )