PathOpsSimplifyRectThreadedTest.cpp 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204
  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 "include/core/SkString.h"
  8. #include "include/private/SkMacros.h"
  9. #include "tests/PathOpsExtendedTest.h"
  10. #include "tests/PathOpsThreadedCommon.h"
  11. // four rects, of four sizes
  12. // for 3 smaller sizes, tall, wide
  13. // top upper mid lower bottom aligned (3 bits, 5 values)
  14. // same with x (3 bits, 5 values)
  15. // not included, square, tall, wide (2 bits)
  16. // cw or ccw (1 bit)
  17. static void testSimplify4x4RectsMain(PathOpsThreadState* data)
  18. {
  19. SkASSERT(data);
  20. PathOpsThreadState& state = *data;
  21. int aShape = state.fA & 0x03;
  22. SkPath::Direction aCW = state.fA >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
  23. int bShape = state.fB & 0x03;
  24. SkPath::Direction bCW = state.fB >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
  25. int cShape = state.fC & 0x03;
  26. SkPath::Direction cCW = state.fC >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
  27. int dShape = state.fD & 0x03;
  28. SkPath::Direction dCW = state.fD >> 2 ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
  29. for (int aXAlign = 0; aXAlign < 5; ++aXAlign) {
  30. for (int aYAlign = 0; aYAlign < 5; ++aYAlign) {
  31. for (int bXAlign = 0; bXAlign < 5; ++bXAlign) {
  32. for (int bYAlign = 0; bYAlign < 5; ++bYAlign) {
  33. for (int cXAlign = 0; cXAlign < 5; ++cXAlign) {
  34. for (int cYAlign = 0; cYAlign < 5; ++cYAlign) {
  35. for (int dXAlign = 0; dXAlign < 5; ++dXAlign) {
  36. for (int dYAlign = 0; dYAlign < 5; ++dYAlign) {
  37. SkString pathStr;
  38. SkPath path, out;
  39. path.setFillType(SkPath::kWinding_FillType);
  40. int l SK_INIT_TO_AVOID_WARNING, t SK_INIT_TO_AVOID_WARNING,
  41. r SK_INIT_TO_AVOID_WARNING, b SK_INIT_TO_AVOID_WARNING;
  42. if (aShape) {
  43. switch (aShape) {
  44. case 1: // square
  45. l = 0; r = 60;
  46. t = 0; b = 60;
  47. aXAlign = 5;
  48. aYAlign = 5;
  49. break;
  50. case 2:
  51. l = aXAlign * 12;
  52. r = l + 30;
  53. t = 0; b = 60;
  54. aYAlign = 5;
  55. break;
  56. case 3:
  57. l = 0; r = 60;
  58. t = aYAlign * 12;
  59. b = l + 30;
  60. aXAlign = 5;
  61. break;
  62. }
  63. path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
  64. aCW);
  65. if (state.fReporter->verbose()) {
  66. pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
  67. " SkPath::kC%sW_Direction);\n", l, t, r, b, aCW ? "C" : "");
  68. }
  69. } else {
  70. aXAlign = 5;
  71. aYAlign = 5;
  72. }
  73. if (bShape) {
  74. switch (bShape) {
  75. case 1: // square
  76. l = bXAlign * 10;
  77. r = l + 20;
  78. t = bYAlign * 10;
  79. b = l + 20;
  80. break;
  81. case 2:
  82. l = bXAlign * 10;
  83. r = l + 20;
  84. t = 10; b = 40;
  85. bYAlign = 5;
  86. break;
  87. case 3:
  88. l = 10; r = 40;
  89. t = bYAlign * 10;
  90. b = l + 20;
  91. bXAlign = 5;
  92. break;
  93. }
  94. path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
  95. bCW);
  96. if (state.fReporter->verbose()) {
  97. pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
  98. " SkPath::kC%sW_Direction);\n", l, t, r, b, bCW ? "C" : "");
  99. }
  100. } else {
  101. bXAlign = 5;
  102. bYAlign = 5;
  103. }
  104. if (cShape) {
  105. switch (cShape) {
  106. case 1: // square
  107. l = cXAlign * 6;
  108. r = l + 12;
  109. t = cYAlign * 6;
  110. b = l + 12;
  111. break;
  112. case 2:
  113. l = cXAlign * 6;
  114. r = l + 12;
  115. t = 20; b = 30;
  116. cYAlign = 5;
  117. break;
  118. case 3:
  119. l = 20; r = 30;
  120. t = cYAlign * 6;
  121. b = l + 20;
  122. cXAlign = 5;
  123. break;
  124. }
  125. path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
  126. cCW);
  127. if (state.fReporter->verbose()) {
  128. pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
  129. " SkPath::kC%sW_Direction);\n", l, t, r, b, cCW ? "C" : "");
  130. }
  131. } else {
  132. cXAlign = 5;
  133. cYAlign = 5;
  134. }
  135. if (dShape) {
  136. switch (dShape) {
  137. case 1: // square
  138. l = dXAlign * 4;
  139. r = l + 9;
  140. t = dYAlign * 4;
  141. b = l + 9;
  142. break;
  143. case 2:
  144. l = dXAlign * 6;
  145. r = l + 9;
  146. t = 32; b = 36;
  147. dYAlign = 5;
  148. break;
  149. case 3:
  150. l = 32; r = 36;
  151. t = dYAlign * 6;
  152. b = l + 9;
  153. dXAlign = 5;
  154. break;
  155. }
  156. path.addRect(SkIntToScalar(l), SkIntToScalar(t), SkIntToScalar(r), SkIntToScalar(b),
  157. dCW);
  158. if (state.fReporter->verbose()) {
  159. pathStr.appendf(" path.addRect(%d, %d, %d, %d,"
  160. " SkPath::kC%sW_Direction);\n", l, t, r, b, dCW ? "C" : "");
  161. }
  162. } else {
  163. dXAlign = 5;
  164. dYAlign = 5;
  165. }
  166. path.close();
  167. if (state.fReporter->verbose()) {
  168. state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
  169. }
  170. testSimplify(path, false, out, state, pathStr.c_str());
  171. if (state.fReporter->verbose()) {
  172. state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
  173. }
  174. testSimplify(path, true, out, state, pathStr.c_str());
  175. }
  176. }
  177. }
  178. }
  179. }
  180. }
  181. }
  182. }
  183. }
  184. DEF_TEST(PathOpsSimplifyRectsThreaded, reporter) {
  185. initializeTests(reporter, "testLine");
  186. PathOpsThreadedTestRunner testRunner(reporter);
  187. for (int a = 0; a < 8; ++a) { // outermost
  188. for (int b = a ; b < 8; ++b) {
  189. for (int c = b ; c < 8; ++c) {
  190. for (int d = c; d < 8; ++d) {
  191. *testRunner.fRunnables.append() = new PathOpsThreadedRunnable(
  192. &testSimplify4x4RectsMain, a, b, c, d, &testRunner);
  193. }
  194. if (!reporter->allowExtendedTest()) goto finish;
  195. }
  196. }
  197. }
  198. finish:
  199. testRunner.render();
  200. }