SampleSlides.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458
  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 "include/core/SkCanvas.h"
  8. #include "include/core/SkPaint.h"
  9. #include "include/core/SkVertices.h"
  10. #include "include/effects/SkBlurMaskFilter.h"
  11. #include "include/effects/SkGradientShader.h"
  12. #include "samplecode/Sample.h"
  13. #include "src/core/SkBlurMask.h"
  14. #include "src/core/SkReadBuffer.h"
  15. #include "src/core/SkWriteBuffer.h"
  16. #include "tools/ToolUtils.h"
  17. #define BG_COLOR 0xFFDDDDDD
  18. typedef void (*SlideProc)(SkCanvas*);
  19. ///////////////////////////////////////////////////////////////////////////////
  20. #include "include/effects/Sk1DPathEffect.h"
  21. #include "include/effects/Sk2DPathEffect.h"
  22. #include "include/effects/SkCornerPathEffect.h"
  23. #include "include/effects/SkDashPathEffect.h"
  24. #include "include/effects/SkDiscretePathEffect.h"
  25. static void compose_pe(SkPaint* paint) {
  26. SkPathEffect* pe = paint->getPathEffect();
  27. sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
  28. sk_sp<SkPathEffect> compose;
  29. if (pe) {
  30. compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
  31. } else {
  32. compose = corner;
  33. }
  34. paint->setPathEffect(compose);
  35. }
  36. static void hair_pe(SkPaint* paint) {
  37. paint->setStrokeWidth(0);
  38. }
  39. static void hair2_pe(SkPaint* paint) {
  40. paint->setStrokeWidth(0);
  41. compose_pe(paint);
  42. }
  43. static void stroke_pe(SkPaint* paint) {
  44. paint->setStrokeWidth(12);
  45. compose_pe(paint);
  46. }
  47. static void dash_pe(SkPaint* paint) {
  48. SkScalar inter[] = { 20, 10, 10, 10 };
  49. paint->setStrokeWidth(12);
  50. paint->setPathEffect(SkDashPathEffect::Make(inter, SK_ARRAY_COUNT(inter), 0));
  51. compose_pe(paint);
  52. }
  53. static const int gXY[] = {
  54. 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
  55. };
  56. static void scale(SkPath* path, SkScalar scale) {
  57. SkMatrix m;
  58. m.setScale(scale, scale);
  59. path->transform(m);
  60. }
  61. static void one_d_pe(SkPaint* paint) {
  62. SkPath path;
  63. path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
  64. for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
  65. path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
  66. path.close();
  67. path.offset(SkIntToScalar(-6), 0);
  68. scale(&path, 1.5f);
  69. paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0,
  70. SkPath1DPathEffect::kRotate_Style));
  71. compose_pe(paint);
  72. }
  73. typedef void (*PE_Proc)(SkPaint*);
  74. static const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
  75. static void fill_pe(SkPaint* paint) {
  76. paint->setStyle(SkPaint::kFill_Style);
  77. paint->setPathEffect(nullptr);
  78. }
  79. static void discrete_pe(SkPaint* paint) {
  80. paint->setPathEffect(SkDiscretePathEffect::Make(10, 4));
  81. }
  82. static sk_sp<SkPathEffect> MakeTileEffect() {
  83. SkMatrix m;
  84. m.setScale(SkIntToScalar(12), SkIntToScalar(12));
  85. SkPath path;
  86. path.addCircle(0, 0, SkIntToScalar(5));
  87. return SkPath2DPathEffect::Make(m, path);
  88. }
  89. static void tile_pe(SkPaint* paint) {
  90. paint->setPathEffect(MakeTileEffect());
  91. }
  92. static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe };
  93. static void patheffect_slide(SkCanvas* canvas) {
  94. SkPaint paint;
  95. paint.setAntiAlias(true);
  96. paint.setStyle(SkPaint::kStroke_Style);
  97. SkPath path;
  98. path.moveTo(20, 20);
  99. path.lineTo(70, 120);
  100. path.lineTo(120, 30);
  101. path.lineTo(170, 80);
  102. path.lineTo(240, 50);
  103. size_t i;
  104. canvas->save();
  105. for (i = 0; i < SK_ARRAY_COUNT(gPE); i++) {
  106. gPE[i](&paint);
  107. canvas->drawPath(path, paint);
  108. canvas->translate(0, 75);
  109. }
  110. canvas->restore();
  111. path.reset();
  112. SkRect r = { 0, 0, 250, 120 };
  113. path.addOval(r, SkPath::kCW_Direction);
  114. r.inset(50, 50);
  115. path.addRect(r, SkPath::kCCW_Direction);
  116. canvas->translate(320, 20);
  117. for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
  118. gPE2[i](&paint);
  119. canvas->drawPath(path, paint);
  120. canvas->translate(0, 160);
  121. }
  122. }
  123. ///////////////////////////////////////////////////////////////////////////////
  124. #include "include/effects/SkGradientShader.h"
  125. struct GradData {
  126. int fCount;
  127. const SkColor* fColors;
  128. const SkScalar* fPos;
  129. };
  130. static const SkColor gColors[] = {
  131. SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
  132. };
  133. static const SkScalar gPos0[] = { 0, SK_Scalar1 };
  134. static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
  135. static const SkScalar gPos2[] = {
  136. 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
  137. };
  138. static const GradData gGradData[] = {
  139. { 2, gColors, nullptr },
  140. { 2, gColors, gPos0 },
  141. { 2, gColors, gPos1 },
  142. { 5, gColors, nullptr },
  143. { 5, gColors, gPos2 }
  144. };
  145. static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
  146. return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
  147. }
  148. static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
  149. SkPoint center;
  150. center.set(SkScalarAve(pts[0].fX, pts[1].fX),
  151. SkScalarAve(pts[0].fY, pts[1].fY));
  152. return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
  153. data.fPos, data.fCount, tm);
  154. }
  155. static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
  156. SkPoint center;
  157. center.set(SkScalarAve(pts[0].fX, pts[1].fX),
  158. SkScalarAve(pts[0].fY, pts[1].fY));
  159. return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
  160. }
  161. static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkTileMode tm) {
  162. SkPoint center0, center1;
  163. center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
  164. SkScalarAve(pts[0].fY, pts[1].fY));
  165. center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
  166. SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
  167. return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
  168. center0, (pts[1].fX - pts[0].fX) / 2,
  169. data.fColors, data.fPos, data.fCount, tm);
  170. }
  171. typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkTileMode);
  172. static const GradMaker gGradMakers[] = {
  173. MakeLinear, MakeRadial, MakeSweep, Make2Conical
  174. };
  175. static void gradient_slide(SkCanvas* canvas) {
  176. SkPoint pts[2] = {
  177. { 0, 0 },
  178. { SkIntToScalar(100), SkIntToScalar(100) }
  179. };
  180. SkTileMode tm = SkTileMode::kClamp;
  181. SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
  182. SkPaint paint;
  183. paint.setAntiAlias(true);
  184. paint.setDither(true);
  185. canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
  186. for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
  187. canvas->save();
  188. for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
  189. paint.setShader(gGradMakers[j](pts, gGradData[i], tm));
  190. canvas->drawRect(r, paint);
  191. canvas->translate(0, SkIntToScalar(120));
  192. }
  193. canvas->restore();
  194. canvas->translate(SkIntToScalar(120), 0);
  195. }
  196. }
  197. ///////////////////////////////////////////////////////////////////////////////
  198. #include "include/core/SkStream.h"
  199. #include "include/utils/SkRandom.h"
  200. #include "samplecode/DecodeFile.h"
  201. #include "src/core/SkOSFile.h"
  202. static sk_sp<SkShader> make_shader0(SkIPoint* size) {
  203. SkBitmap bm;
  204. decode_file("/skimages/logo.gif", &bm);
  205. size->set(bm.width(), bm.height());
  206. return bm.makeShader();
  207. }
  208. static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
  209. SkPoint pts[] = { { 0, 0 },
  210. { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
  211. SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
  212. return SkGradientShader::MakeLinear(pts, colors, nullptr,
  213. SK_ARRAY_COUNT(colors), SkTileMode::kMirror);
  214. }
  215. class Rec {
  216. public:
  217. SkVertices::VertexMode fMode;
  218. int fCount;
  219. SkPoint* fVerts;
  220. SkPoint* fTexs;
  221. Rec() : fCount(0), fVerts(nullptr), fTexs(nullptr) {}
  222. ~Rec() { delete[] fVerts; delete[] fTexs; }
  223. };
  224. static void make_tris(Rec* rec) {
  225. int n = 10;
  226. SkRandom rand;
  227. rec->fMode = SkVertices::kTriangles_VertexMode;
  228. rec->fCount = n * 3;
  229. rec->fVerts = new SkPoint[rec->fCount];
  230. for (int i = 0; i < n; i++) {
  231. SkPoint* v = &rec->fVerts[i*3];
  232. for (int j = 0; j < 3; j++) {
  233. v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
  234. }
  235. }
  236. }
  237. static void make_fan(Rec* rec, int texWidth, int texHeight) {
  238. const SkScalar tx = SkIntToScalar(texWidth);
  239. const SkScalar ty = SkIntToScalar(texHeight);
  240. const int n = 24;
  241. rec->fMode = SkVertices::kTriangleFan_VertexMode;
  242. rec->fCount = n + 2;
  243. rec->fVerts = new SkPoint[rec->fCount];
  244. rec->fTexs = new SkPoint[rec->fCount];
  245. SkPoint* v = rec->fVerts;
  246. SkPoint* t = rec->fTexs;
  247. v[0].set(0, 0);
  248. t[0].set(0, 0);
  249. for (int i = 0; i < n; i++) {
  250. SkScalar r = SK_ScalarPI * 2 * i / n,
  251. sin = SkScalarSin(r),
  252. cos = SkScalarCos(r);
  253. v[i+1].set(cos, sin);
  254. t[i+1].set(i*tx/n, ty);
  255. }
  256. v[n+1] = v[1];
  257. t[n+1].set(tx, ty);
  258. SkMatrix m;
  259. m.setScale(SkIntToScalar(100), SkIntToScalar(100));
  260. m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
  261. m.mapPoints(v, rec->fCount);
  262. }
  263. static void make_strip(Rec* rec, int texWidth, int texHeight) {
  264. const SkScalar tx = SkIntToScalar(texWidth);
  265. const SkScalar ty = SkIntToScalar(texHeight);
  266. const int n = 24;
  267. rec->fMode = SkVertices::kTriangleStrip_VertexMode;
  268. rec->fCount = 2 * (n + 1);
  269. rec->fVerts = new SkPoint[rec->fCount];
  270. rec->fTexs = new SkPoint[rec->fCount];
  271. SkPoint* v = rec->fVerts;
  272. SkPoint* t = rec->fTexs;
  273. for (int i = 0; i < n; i++) {
  274. SkScalar r = SK_ScalarPI * 2 * i / n,
  275. sin = SkScalarSin(r),
  276. cos = SkScalarCos(r);
  277. v[i*2 + 0].set(cos/2, sin/2);
  278. v[i*2 + 1].set(cos, sin);
  279. t[i*2 + 0].set(tx * i / n, ty);
  280. t[i*2 + 1].set(tx * i / n, 0);
  281. }
  282. v[2*n + 0] = v[0];
  283. v[2*n + 1] = v[1];
  284. t[2*n + 0].set(tx, ty);
  285. t[2*n + 1].set(tx, 0);
  286. SkMatrix m;
  287. m.setScale(SkIntToScalar(100), SkIntToScalar(100));
  288. m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
  289. m.mapPoints(v, rec->fCount);
  290. }
  291. static void mesh_slide(SkCanvas* canvas) {
  292. Rec fRecs[3];
  293. SkIPoint size;
  294. auto fShader0 = make_shader0(&size);
  295. auto fShader1 = make_shader1(size);
  296. make_strip(&fRecs[0], size.fX, size.fY);
  297. make_fan(&fRecs[1], size.fX, size.fY);
  298. make_tris(&fRecs[2]);
  299. SkPaint paint;
  300. paint.setDither(true);
  301. paint.setFilterQuality(kLow_SkFilterQuality);
  302. for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
  303. auto verts = SkVertices::MakeCopy(fRecs[i].fMode, fRecs[i].fCount,
  304. fRecs[i].fVerts, fRecs[i].fTexs, nullptr);
  305. canvas->save();
  306. paint.setShader(nullptr);
  307. canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
  308. canvas->translate(SkIntToScalar(210), 0);
  309. paint.setShader(fShader0);
  310. canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
  311. canvas->translate(SkIntToScalar(210), 0);
  312. paint.setShader(fShader1);
  313. canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
  314. canvas->restore();
  315. canvas->translate(0, SkIntToScalar(250));
  316. }
  317. }
  318. ///////////////////////////////////////////////////////////////////////////////
  319. #include "include/core/SkTypeface.h"
  320. ///////////////////////////////////////////////////////////////////////////////
  321. #include "include/core/SkImageEncoder.h"
  322. static const SlideProc gProc[] = {
  323. patheffect_slide,
  324. gradient_slide,
  325. mesh_slide,
  326. };
  327. class SlideView : public Sample {
  328. int fIndex;
  329. bool fOnce;
  330. public:
  331. SlideView() {
  332. fOnce = false;
  333. }
  334. void init() {
  335. if (fOnce) {
  336. return;
  337. }
  338. fOnce = true;
  339. fIndex = 0;
  340. SkBitmap bm;
  341. bm.allocN32Pixels(1024, 768);
  342. SkCanvas canvas(bm);
  343. SkScalar s = SkIntToScalar(1024) / 640;
  344. canvas.scale(s, s);
  345. for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); i++) {
  346. canvas.save();
  347. canvas.drawColor(BG_COLOR);
  348. gProc[i](&canvas);
  349. canvas.restore();
  350. SkString str;
  351. str.printf("/skimages/slide_" SK_SIZE_T_SPECIFIER ".png", i);
  352. ToolUtils::EncodeImageToFile(str.c_str(), bm, SkEncodedImageFormat::kPNG, 100);
  353. }
  354. this->setBGColor(BG_COLOR);
  355. }
  356. protected:
  357. SkString name() override { return SkString("Slides"); }
  358. void onDrawContent(SkCanvas* canvas) override {
  359. this->init();
  360. gProc[fIndex](canvas);
  361. }
  362. Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, ModifierKey) override {
  363. this->init();
  364. fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
  365. return nullptr;
  366. }
  367. private:
  368. typedef Sample INHERITED;
  369. };
  370. //////////////////////////////////////////////////////////////////////////////
  371. DEF_SAMPLE( return new SlideView(); )