HairlinePathBench.cpp 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. /*
  2. * Copyright 2013 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 "bench/Benchmark.h"
  8. #include "include/core/SkCanvas.h"
  9. #include "include/core/SkPaint.h"
  10. #include "include/core/SkPath.h"
  11. #include "include/core/SkShader.h"
  12. #include "include/core/SkString.h"
  13. #include "include/utils/SkRandom.h"
  14. enum Flags {
  15. kBig_Flag = 1 << 0,
  16. kAA_Flag = 1 << 1
  17. };
  18. #define FLAGS00 Flags(0)
  19. #define FLAGS01 Flags(kBig_Flag)
  20. #define FLAGS10 Flags(kAA_Flag)
  21. #define FLAGS11 Flags(kBig_Flag | kAA_Flag)
  22. static const int points[] = {
  23. 10, 10, 15, 5, 20, 20,
  24. 30, 5, 25, 20, 15, 12,
  25. 21, 21, 30, 30, 12, 4,
  26. 32, 28, 20, 18, 12, 10
  27. };
  28. static const int kMaxPathSize = 10;
  29. class HairlinePathBench : public Benchmark {
  30. public:
  31. HairlinePathBench(Flags flags) : fFlags(flags) {
  32. fPaint.setStyle(SkPaint::kStroke_Style);
  33. fPaint.setStrokeWidth(SkIntToScalar(0));
  34. }
  35. virtual void appendName(SkString*) = 0;
  36. virtual void makePath(SkPath*) = 0;
  37. protected:
  38. const char* onGetName() override {
  39. fName.printf("path_hairline_%s_%s_",
  40. fFlags & kBig_Flag ? "big" : "small",
  41. fFlags & kAA_Flag ? "AA" : "noAA");
  42. this->appendName(&fName);
  43. return fName.c_str();
  44. }
  45. void onDraw(int loops, SkCanvas* canvas) override {
  46. SkPaint paint(fPaint);
  47. this->setupPaint(&paint);
  48. paint.setAntiAlias(fFlags & kAA_Flag ? true : false);
  49. SkPath path;
  50. this->makePath(&path);
  51. if (fFlags & kBig_Flag) {
  52. const SkMatrix m = SkMatrix::MakeScale(SkIntToScalar(3), SkIntToScalar(3));
  53. path.transform(m);
  54. }
  55. for (int i = 0; i < loops; i++) {
  56. for (int j = 0; j < 100; ++j) {
  57. canvas->drawPath(path, paint);
  58. }
  59. }
  60. }
  61. private:
  62. SkPaint fPaint;
  63. SkString fName;
  64. Flags fFlags;
  65. typedef Benchmark INHERITED;
  66. };
  67. class LinePathBench : public HairlinePathBench {
  68. public:
  69. LinePathBench(Flags flags) : INHERITED(flags) {}
  70. void appendName(SkString* name) override {
  71. name->append("line");
  72. }
  73. void makePath(SkPath* path) override {
  74. SkRandom rand;
  75. int size = SK_ARRAY_COUNT(points);
  76. int hSize = size / 2;
  77. for (int i = 0; i < kMaxPathSize; ++i) {
  78. int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
  79. int yTrans = 0;
  80. if (i > kMaxPathSize/2 - 1) {
  81. yTrans = 40;
  82. }
  83. int base1 = 2 * rand.nextULessThan(hSize);
  84. int base2 = 2 * rand.nextULessThan(hSize);
  85. int base3 = 2 * rand.nextULessThan(hSize);
  86. path->moveTo(SkIntToScalar(points[base1] + xTrans),
  87. SkIntToScalar(points[base1+1] + yTrans));
  88. path->lineTo(SkIntToScalar(points[base2] + xTrans),
  89. SkIntToScalar(points[base2+1] + yTrans));
  90. path->lineTo(SkIntToScalar(points[base3] + xTrans),
  91. SkIntToScalar(points[base3+1] + yTrans));
  92. }
  93. }
  94. private:
  95. typedef HairlinePathBench INHERITED;
  96. };
  97. class QuadPathBench : public HairlinePathBench {
  98. public:
  99. QuadPathBench(Flags flags) : INHERITED(flags) {}
  100. void appendName(SkString* name) override {
  101. name->append("quad");
  102. }
  103. void makePath(SkPath* path) override {
  104. SkRandom rand;
  105. int size = SK_ARRAY_COUNT(points);
  106. int hSize = size / 2;
  107. for (int i = 0; i < kMaxPathSize; ++i) {
  108. int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
  109. int yTrans = 0;
  110. if (i > kMaxPathSize/2 - 1) {
  111. yTrans = 40;
  112. }
  113. int base1 = 2 * rand.nextULessThan(hSize);
  114. int base2 = 2 * rand.nextULessThan(hSize);
  115. int base3 = 2 * rand.nextULessThan(hSize);
  116. path->moveTo(SkIntToScalar(points[base1] + xTrans),
  117. SkIntToScalar(points[base1+1] + yTrans));
  118. path->quadTo(SkIntToScalar(points[base2] + xTrans),
  119. SkIntToScalar(points[base2+1] + yTrans),
  120. SkIntToScalar(points[base3] + xTrans),
  121. SkIntToScalar(points[base3+1] + yTrans));
  122. }
  123. }
  124. private:
  125. typedef HairlinePathBench INHERITED;
  126. };
  127. class ConicPathBench : public HairlinePathBench {
  128. public:
  129. ConicPathBench(Flags flags) : INHERITED(flags) {}
  130. void appendName(SkString* name) override {
  131. name->append("conic");
  132. }
  133. void makePath(SkPath* path) override {
  134. SkRandom rand;
  135. SkRandom randWeight;
  136. int size = SK_ARRAY_COUNT(points);
  137. int hSize = size / 2;
  138. for (int i = 0; i < kMaxPathSize; ++i) {
  139. int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
  140. int yTrans = 0;
  141. if (i > kMaxPathSize/2 - 1) {
  142. yTrans = 40;
  143. }
  144. int base1 = 2 * rand.nextULessThan(hSize);
  145. int base2 = 2 * rand.nextULessThan(hSize);
  146. int base3 = 2 * rand.nextULessThan(hSize);
  147. float weight = randWeight.nextRangeF(0.0f, 2.0f);
  148. path->moveTo(SkIntToScalar(points[base1] + xTrans),
  149. SkIntToScalar(points[base1+1] + yTrans));
  150. path->conicTo(SkIntToScalar(points[base2] + xTrans),
  151. SkIntToScalar(points[base2+1] + yTrans),
  152. SkIntToScalar(points[base3] + xTrans),
  153. SkIntToScalar(points[base3+1] + yTrans),
  154. weight);
  155. }
  156. }
  157. private:
  158. typedef HairlinePathBench INHERITED;
  159. };
  160. class CubicPathBench : public HairlinePathBench {
  161. public:
  162. CubicPathBench(Flags flags) : INHERITED(flags) {}
  163. void appendName(SkString* name) override {
  164. name->append("cubic");
  165. }
  166. void makePath(SkPath* path) override {
  167. SkRandom rand;
  168. int size = SK_ARRAY_COUNT(points);
  169. int hSize = size / 2;
  170. for (int i = 0; i < kMaxPathSize; ++i) {
  171. int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
  172. int yTrans = 0;
  173. if (i > kMaxPathSize/2 - 1) {
  174. yTrans = 40;
  175. }
  176. int base1 = 2 * rand.nextULessThan(hSize);
  177. int base2 = 2 * rand.nextULessThan(hSize);
  178. int base3 = 2 * rand.nextULessThan(hSize);
  179. int base4 = 2 * rand.nextULessThan(hSize);
  180. path->moveTo(SkIntToScalar(points[base1] + xTrans),
  181. SkIntToScalar(points[base1+1] + yTrans));
  182. path->cubicTo(SkIntToScalar(points[base2] + xTrans),
  183. SkIntToScalar(points[base2+1] + yTrans),
  184. SkIntToScalar(points[base3] + xTrans),
  185. SkIntToScalar(points[base3+1] + yTrans),
  186. SkIntToScalar(points[base4] + xTrans),
  187. SkIntToScalar(points[base4+1] + yTrans));
  188. }
  189. }
  190. private:
  191. typedef HairlinePathBench INHERITED;
  192. };
  193. // FLAG00 - no AA, small
  194. // FLAG01 - no AA, small
  195. // FLAG10 - AA, big
  196. // FLAG11 - AA, big
  197. DEF_BENCH( return new LinePathBench(FLAGS00); )
  198. DEF_BENCH( return new LinePathBench(FLAGS01); )
  199. DEF_BENCH( return new LinePathBench(FLAGS10); )
  200. DEF_BENCH( return new LinePathBench(FLAGS11); )
  201. DEF_BENCH( return new QuadPathBench(FLAGS00); )
  202. DEF_BENCH( return new QuadPathBench(FLAGS01); )
  203. DEF_BENCH( return new QuadPathBench(FLAGS10); )
  204. DEF_BENCH( return new QuadPathBench(FLAGS11); )
  205. // Don't have default path renderer for conics yet on GPU, so must use AA
  206. // DEF_BENCH( return new ConicPathBench(FLAGS00); )
  207. // DEF_BENCH( return new ConicPathBench(FLAGS01); )
  208. DEF_BENCH( return new ConicPathBench(FLAGS10); )
  209. DEF_BENCH( return new ConicPathBench(FLAGS11); )
  210. DEF_BENCH( return new CubicPathBench(FLAGS00); )
  211. DEF_BENCH( return new CubicPathBench(FLAGS01); )
  212. DEF_BENCH( return new CubicPathBench(FLAGS10); )
  213. DEF_BENCH( return new CubicPathBench(FLAGS11); )