composeshader.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370
  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. #include "gm/gm.h"
  8. #include "include/core/SkBitmap.h"
  9. #include "include/core/SkBlendMode.h"
  10. #include "include/core/SkCanvas.h"
  11. #include "include/core/SkColor.h"
  12. #include "include/core/SkColorPriv.h"
  13. #include "include/core/SkImage.h"
  14. #include "include/core/SkImageInfo.h"
  15. #include "include/core/SkMatrix.h"
  16. #include "include/core/SkPaint.h"
  17. #include "include/core/SkPoint.h"
  18. #include "include/core/SkRect.h"
  19. #include "include/core/SkRefCnt.h"
  20. #include "include/core/SkScalar.h"
  21. #include "include/core/SkShader.h"
  22. #include "include/core/SkSize.h"
  23. #include "include/core/SkString.h"
  24. #include "include/core/SkTileMode.h"
  25. #include "include/core/SkTypes.h"
  26. #include "include/effects/SkGradientShader.h"
  27. #include "include/private/SkTDArray.h"
  28. #include "src/core/SkTLazy.h"
  29. #include <utility>
  30. static sk_sp<SkShader> make_shader(SkBlendMode mode) {
  31. SkPoint pts[2];
  32. SkColor colors[2];
  33. pts[0].set(0, 0);
  34. pts[1].set(SkIntToScalar(100), 0);
  35. colors[0] = SK_ColorRED;
  36. colors[1] = SK_ColorBLUE;
  37. auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  38. pts[0].set(0, 0);
  39. pts[1].set(0, SkIntToScalar(100));
  40. colors[0] = SK_ColorBLACK;
  41. colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
  42. auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  43. return SkShaders::Blend(mode, std::move(shaderA), std::move(shaderB));
  44. }
  45. class ComposeShaderGM : public skiagm::GM {
  46. public:
  47. ComposeShaderGM() {
  48. fShader = make_shader(SkBlendMode::kDstIn);
  49. }
  50. protected:
  51. SkString onShortName() override {
  52. return SkString("composeshader");
  53. }
  54. SkISize onISize() override {
  55. return SkISize::Make(120, 120);
  56. }
  57. void onDraw(SkCanvas* canvas) override {
  58. SkPaint paint;
  59. paint.setColor(SK_ColorGREEN);
  60. canvas->drawRect(SkRect::MakeWH(100, 100), paint);
  61. paint.setShader(fShader);
  62. canvas->drawRect(SkRect::MakeWH(100, 100), paint);
  63. }
  64. protected:
  65. sk_sp<SkShader> fShader;
  66. private:
  67. typedef GM INHERITED ;
  68. };
  69. DEF_GM( return new ComposeShaderGM; )
  70. class ComposeShaderAlphaGM : public skiagm::GM {
  71. public:
  72. ComposeShaderAlphaGM() {}
  73. protected:
  74. SkString onShortName() override {
  75. return SkString("composeshader_alpha");
  76. }
  77. SkISize onISize() override {
  78. return SkISize::Make(750, 220);
  79. }
  80. void onDraw(SkCanvas* canvas) override {
  81. sk_sp<SkShader> shaders[] = {
  82. make_shader(SkBlendMode::kDstIn),
  83. make_shader(SkBlendMode::kSrcOver),
  84. };
  85. SkPaint paint;
  86. paint.setColor(SK_ColorGREEN);
  87. const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100);
  88. for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
  89. canvas->save();
  90. for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
  91. paint.setAlphaf(1.0f);
  92. paint.setShader(nullptr);
  93. canvas->drawRect(r, paint);
  94. paint.setAlpha(alpha);
  95. paint.setShader(shaders[y]);
  96. canvas->drawRect(r, paint);
  97. canvas->translate(r.width() + 5, 0);
  98. }
  99. canvas->restore();
  100. canvas->translate(0, r.height() + 5);
  101. }
  102. }
  103. private:
  104. typedef GM INHERITED ;
  105. };
  106. DEF_GM( return new ComposeShaderAlphaGM; )
  107. // creates a square bitmap with red background and a green circle in the center
  108. static void draw_color_bm(SkBitmap* bm, int length) {
  109. SkPaint paint;
  110. paint.setColor(SK_ColorGREEN);
  111. bm->allocN32Pixels(length, length);
  112. bm->eraseColor(SK_ColorRED);
  113. SkCanvas canvas(*bm);
  114. canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/2),
  115. paint);
  116. }
  117. // creates a square alpha8 bitmap with transparent background and an opaque circle in the center
  118. static void draw_alpha8_bm(SkBitmap* bm, int length) {
  119. SkPaint circlePaint;
  120. circlePaint.setColor(SK_ColorBLACK);
  121. bm->allocPixels(SkImageInfo::MakeA8(length, length));
  122. bm->eraseColor(SK_ColorTRANSPARENT);
  123. SkCanvas canvas(*bm);
  124. canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/4),
  125. circlePaint);
  126. }
  127. // creates a linear gradient shader
  128. static sk_sp<SkShader> make_linear_gradient_shader(int length) {
  129. SkPoint pts[2];
  130. SkColor colors[2];
  131. pts[0].set(0, 0);
  132. pts[1].set(SkIntToScalar(length), 0);
  133. colors[0] = SK_ColorBLUE;
  134. colors[1] = SkColorSetARGB(0, 0, 0, 0xFF);
  135. return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  136. }
  137. class ComposeShaderBitmapGM : public skiagm::GM {
  138. public:
  139. ComposeShaderBitmapGM(bool use_lm) : fUseLocalMatrix(use_lm) {}
  140. protected:
  141. void onOnceBeforeDraw() override {
  142. draw_color_bm(&fColorBitmap, squareLength);
  143. draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
  144. SkMatrix s;
  145. s.reset();
  146. fColorBitmapShader = fColorBitmap.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &s);
  147. fAlpha8BitmapShader = fAlpha8Bitmap.makeShader(SkTileMode::kRepeat,
  148. SkTileMode::kRepeat, &s);
  149. fLinearGradientShader = make_linear_gradient_shader(squareLength);
  150. }
  151. SkString onShortName() override {
  152. return SkStringPrintf("composeshader_bitmap%s", fUseLocalMatrix ? "_lm" : "");
  153. }
  154. SkISize onISize() override {
  155. return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5));
  156. }
  157. void onDraw(SkCanvas* canvas) override {
  158. SkBlendMode mode = SkBlendMode::kDstOver;
  159. SkTLazy<SkMatrix> lm;
  160. if (fUseLocalMatrix) {
  161. lm.set(SkMatrix::MakeTrans(0, squareLength * 0.5f));
  162. }
  163. sk_sp<SkShader> shaders[] = {
  164. // gradient should appear over color bitmap
  165. SkShaders::Blend(mode, fLinearGradientShader, fColorBitmapShader, lm.getMaybeNull()),
  166. // gradient should appear over alpha8 bitmap colorized by the paint color
  167. SkShaders::Blend(mode, fLinearGradientShader, fAlpha8BitmapShader, lm.getMaybeNull()),
  168. };
  169. SkPaint paint;
  170. paint.setColor(SK_ColorYELLOW);
  171. const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength),
  172. SkIntToScalar(squareLength));
  173. for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
  174. canvas->save();
  175. for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
  176. paint.setAlpha(alpha);
  177. paint.setShader(shaders[y]);
  178. canvas->drawRect(r, paint);
  179. canvas->translate(r.width() + 5, 0);
  180. }
  181. canvas->restore();
  182. canvas->translate(0, r.height() + 5);
  183. }
  184. }
  185. private:
  186. /** This determines the length and width of the bitmaps used in the ComposeShaders. Values
  187. * above 20 may cause an SkASSERT to fail in SkSmallAllocator. However, larger values will
  188. * work in a release build. You can change this parameter and then compile a release build
  189. * to have this GM draw larger bitmaps for easier visual inspection.
  190. */
  191. static constexpr int squareLength = 20;
  192. const bool fUseLocalMatrix;
  193. SkBitmap fColorBitmap;
  194. SkBitmap fAlpha8Bitmap;
  195. sk_sp<SkShader> fColorBitmapShader;
  196. sk_sp<SkShader> fAlpha8BitmapShader;
  197. sk_sp<SkShader> fLinearGradientShader;
  198. typedef GM INHERITED;
  199. };
  200. DEF_GM( return new ComposeShaderBitmapGM(false); )
  201. DEF_GM( return new ComposeShaderBitmapGM(true); )
  202. DEF_SIMPLE_GM(composeshader_bitmap2, canvas, 200, 200) {
  203. int width = 255;
  204. int height = 255;
  205. SkTDArray<uint8_t> dst8Storage;
  206. dst8Storage.setCount(width * height);
  207. SkTDArray<uint32_t> dst32Storage;
  208. dst32Storage.setCount(width * height * sizeof(int32_t));
  209. for (int y = 0; y < height; ++y) {
  210. for (int x = 0; x < width; ++x) {
  211. dst8Storage[y * width + x] = (y + x) / 2;
  212. dst32Storage[y * width + x] = SkPackARGB32(0xFF, x, y, 0);
  213. }
  214. }
  215. SkPaint paint;
  216. paint.setAntiAlias(true);
  217. paint.setColor(SK_ColorBLUE);
  218. SkRect r = {0, 0, SkIntToScalar(width), SkIntToScalar(height)};
  219. canvas->drawRect(r, paint);
  220. SkBitmap skBitmap, skMask;
  221. SkImageInfo imageInfo = SkImageInfo::Make(width, height,
  222. SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
  223. skBitmap.installPixels(imageInfo, dst32Storage.begin(), width * sizeof(int32_t),
  224. nullptr, nullptr);
  225. imageInfo = SkImageInfo::Make(width, height,
  226. SkColorType::kAlpha_8_SkColorType, kPremul_SkAlphaType);
  227. skMask.installPixels(imageInfo, dst8Storage.begin(), width, nullptr, nullptr);
  228. sk_sp<SkImage> skSrc = SkImage::MakeFromBitmap(skBitmap);
  229. sk_sp<SkImage> skMaskImage = SkImage::MakeFromBitmap(skMask);
  230. paint.setShader(
  231. SkShaders::Blend(SkBlendMode::kSrcIn, skMaskImage->makeShader(), skSrc->makeShader()));
  232. canvas->drawRect(r, paint);
  233. }
  234. ///////////////////////////////////////////////////////////////////////////////////////////////////
  235. static sk_sp<SkShader> make_src_shader(SkScalar size) {
  236. const SkPoint pts[] = { { 0, 0 }, { 0, size } };
  237. const SkColor colors[] = { 0xFF0000FF, 0x000000FF };
  238. return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  239. }
  240. static sk_sp<SkShader> make_dst_shader(SkScalar size) {
  241. const SkPoint pts[] = { { 0, 0 }, { size, 0 } };
  242. const SkColor colors[] = { SK_ColorRED, 0x00FF0000 };
  243. return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  244. }
  245. const SkScalar gCellSize = 100;
  246. static void draw_cell(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
  247. SkBlendMode mode, SkAlpha alpha) {
  248. const SkRect r = SkRect::MakeWH(gCellSize, gCellSize);
  249. SkPaint p;
  250. p.setAlpha(alpha);
  251. SkAutoCanvasRestore acr(canvas, false);
  252. canvas->saveLayer(&r, &p);
  253. p.setAlpha(0xFF);
  254. p.setShader(dst);
  255. p.setBlendMode(SkBlendMode::kSrc);
  256. canvas->drawRect(r, p);
  257. p.setShader(src);
  258. p.setBlendMode(mode);
  259. canvas->drawRect(r, p);
  260. }
  261. static void draw_composed(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
  262. SkBlendMode mode, SkAlpha alpha) {
  263. SkPaint p;
  264. p.setAlpha(alpha);
  265. p.setShader(SkShaders::Blend(mode, dst, src));
  266. canvas->drawRect(SkRect::MakeWH(gCellSize, gCellSize), p);
  267. }
  268. static void draw_pair(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
  269. SkBlendMode mode) {
  270. SkAutoCanvasRestore acr(canvas, true);
  271. const SkScalar gap = 4;
  272. SkRect r = SkRect::MakeWH(2 * gCellSize + gap, 2 * gCellSize + gap);
  273. r.outset(gap + 1.5f, gap + 1.5f);
  274. SkPaint p;
  275. p.setStyle(SkPaint::kStroke_Style);
  276. canvas->drawRect(r, p); // border
  277. SkAlpha alpha = 0xFF;
  278. for (int y = 0; y < 2; ++y) {
  279. draw_cell(canvas, src, dst, mode, alpha);
  280. canvas->save();
  281. canvas->translate(gCellSize + gap, 0);
  282. draw_composed(canvas, src, dst, mode, alpha);
  283. canvas->restore();
  284. canvas->translate(0, gCellSize + gap);
  285. alpha = 0x80;
  286. }
  287. }
  288. DEF_SIMPLE_GM(composeshader_grid, canvas, 882, 882) {
  289. auto src = make_src_shader(gCellSize);
  290. auto dst = make_dst_shader(gCellSize);
  291. const SkScalar margin = 15;
  292. const SkScalar dx = 2*gCellSize + margin;
  293. const SkScalar dy = 2*gCellSize + margin;
  294. canvas->translate(margin, margin);
  295. canvas->save();
  296. for (int m = 0; m < 16; ++m) {
  297. SkBlendMode mode = static_cast<SkBlendMode>(m);
  298. draw_pair(canvas, src, dst, mode);
  299. if ((m % 4) == 3) {
  300. canvas->restore();
  301. canvas->translate(0, dy);
  302. canvas->save();
  303. } else {
  304. canvas->translate(dx, 0);
  305. }
  306. }
  307. canvas->restore();
  308. }