| #include "EdgeDemo.h" |
| #include "EdgeWalker_Test.h" |
| #include "ShapeOps.h" |
| #import "SkCanvas.h" |
| #import "SkPaint.h" |
| |
| extern void showPath(const SkPath& path, const char* str); |
| |
| static bool drawPaths(SkCanvas* canvas, const SkPath& path, bool useOld) |
| { |
| SkPath out; |
| #define SHOW_PATH 0 |
| #if SHOW_PATH |
| showPath(path, "original:"); |
| #endif |
| if (useOld) { |
| simplify(path, true, out); |
| } else { |
| simplifyx(path, out); |
| } |
| #if SHOW_PATH |
| showPath(out, "simplified:"); |
| #endif |
| SkPaint paint; |
| paint.setAntiAlias(true); |
| paint.setStyle(SkPaint::kStroke_Style); |
| // paint.setStrokeWidth(6); |
| // paint.setColor(0x1F003f7f); |
| // canvas->drawPath(path, paint); |
| paint.setColor(0xFF305F00); |
| paint.setStrokeWidth(1); |
| canvas->drawPath(out, paint); |
| return true; |
| } |
| |
| // Three circles bounce inside a rectangle. The circles describe three, four |
| // or five points which in turn describe a polygon. The polygon points |
| // bounce inside the circles. The circles rotate and scale over time. The |
| // polygons are combined into a single path, simplified, and stroked. |
| static bool drawCircles(SkCanvas* canvas, int step, bool useOld) |
| { |
| const int circles = 3; |
| int scales[circles]; |
| int angles[circles]; |
| int locs[circles * 2]; |
| int pts[circles * 2 * 4]; |
| int c, p; |
| for (c = 0; c < circles; ++c) { |
| scales[c] = abs(10 - (step + c * 4) % 21); |
| angles[c] = (step + c * 6) % 600; |
| locs[c * 2] = abs(130 - (step + c * 9) % 261); |
| locs[c * 2 + 1] = abs(170 - (step + c * 11) % 341); |
| for (p = 0; p < 4; ++p) { |
| pts[c * 8 + p * 2] = abs(90 - ((step + c * 121 + p * 13) % 190)); |
| pts[c * 8 + p * 2 + 1] = abs(110 - ((step + c * 223 + p * 17) % 230)); |
| } |
| } |
| SkPath path; |
| for (c = 0; c < circles; ++c) { |
| for (p = 0; p < 4; ++p) { |
| SkScalar x = pts[c * 8 + p * 2]; |
| SkScalar y = pts[c * 8 + p * 2 + 1]; |
| x *= 3 + scales[c] / 10.0f; |
| y *= 3 + scales[c] / 10.0f; |
| SkScalar angle = angles[c] * 3.1415f * 2 / 600; |
| SkScalar temp = (SkScalar) (x * cos(angle) - y * sin(angle)); |
| y = (SkScalar) (x * sin(angle) + y * cos(angle)); |
| x = temp; |
| x += locs[c * 2] * 200 / 130.0f; |
| y += locs[c * 2 + 1] * 200 / 170.0f; |
| x += 50; |
| // y += 200; |
| if (p == 0) { |
| path.moveTo(x, y); |
| } else { |
| path.lineTo(x, y); |
| } |
| } |
| path.close(); |
| } |
| return drawPaths(canvas, path, useOld); |
| } |
| |
| static void createStar(SkPath& path, SkScalar innerRadius, SkScalar outerRadius, |
| SkScalar startAngle, int points, SkPoint center) { |
| SkScalar angle = startAngle; |
| for (int index = 0; index < points * 2; ++index) { |
| SkScalar radius = index & 1 ? outerRadius : innerRadius; |
| SkScalar x = (SkScalar) (radius * cos(angle)); |
| SkScalar y = (SkScalar) (radius * sin(angle)); |
| x += center.fX; |
| y += center.fY; |
| if (index == 0) { |
| path.moveTo(x, y); |
| } else { |
| path.lineTo(x, y); |
| } |
| angle += 3.1415f / points; |
| } |
| path.close(); |
| } |
| |
| static bool drawStars(SkCanvas* canvas, int step, bool useOld) |
| { |
| SkPath path; |
| const int stars = 25; |
| int pts[stars]; |
| // static bool initialize = true; |
| int s; |
| for (s = 0; s < stars; ++s) { |
| pts[s] = 4 + (s % 7); |
| } |
| SkPoint locs[stars]; |
| SkScalar angles[stars]; |
| SkScalar innerRadius[stars]; |
| SkScalar outerRadius[stars]; |
| const int width = 640; |
| const int height = 480; |
| const int margin = 30; |
| const int minRadius = 120; |
| const int maxInner = 800; |
| const int maxOuter = 1153; |
| for (s = 0; s < stars; ++s) { |
| int starW = (int) (width - margin * 2 + (SkScalar) s * (stars - s) / stars); |
| locs[s].fX = (int) (step * (1.3f * (s + 1) / stars) + s * 121) % (starW * 2); |
| if (locs[s].fX > starW) { |
| locs[s].fX = starW * 2 - locs[s].fX; |
| } |
| locs[s].fX += margin; |
| int starH = (int) (height - margin * 2 + (SkScalar) s * s / stars); |
| locs[s].fY = (int) (step * (1.7f * (s + 1) / stars) + s * 183) % (starH * 2); |
| if (locs[s].fY > starH) { |
| locs[s].fY = starH * 2 - locs[s].fY; |
| } |
| locs[s].fY += margin; |
| angles[s] = ((step + s * 47) % (360 * 4)) * 3.1415f / 180 / 4; |
| innerRadius[s] = (step + s * 30) % (maxInner * 2); |
| if (innerRadius[s] > maxInner) { |
| innerRadius[s] = (maxInner * 2) - innerRadius[s]; |
| } |
| innerRadius[s] = innerRadius[s] / 4 + minRadius; |
| outerRadius[s] = (step + s * 70) % (maxOuter * 2); |
| if (outerRadius[s] > maxOuter) { |
| outerRadius[s] = (maxOuter * 2) - outerRadius[s]; |
| } |
| outerRadius[s] = outerRadius[s] / 4 + minRadius; |
| createStar(path, innerRadius[s] / 4.0f, outerRadius[s] / 4.0f, |
| angles[s], pts[s], locs[s]); |
| } |
| return drawPaths(canvas, path, useOld); |
| } |
| |
| #if 0 |
| static void tryRoncoOnce(const SkPath& path, const SkRect& target, bool show) { |
| // capture everything in a desired rectangle |
| SkPath tiny; |
| bool closed = true; |
| SkPath::Iter iter(path, false); |
| SkPoint pts[4]; |
| SkPath::Verb verb; |
| int count = 0; |
| SkPoint lastPt; |
| while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { |
| switch (verb) { |
| case SkPath::kMove_Verb: |
| count = 0; |
| break; |
| case SkPath::kLine_Verb: |
| count = 1; |
| break; |
| case SkPath::kQuad_Verb: |
| count = 2; |
| break; |
| case SkPath::kCubic_Verb: |
| count = 3; |
| break; |
| case SkPath::kClose_Verb: |
| if (!closed) { |
| tiny.close(); |
| closed = true; |
| } |
| count = 0; |
| break; |
| default: |
| SkDEBUGFAIL("bad verb"); |
| } |
| if (!count) { |
| continue; |
| } |
| SkRect bounds; |
| bounds.set(pts[0].fX, pts[0].fY, pts[0].fX, pts[0].fY); |
| for (int i = 1; i <= count; ++i) { |
| bounds.growToInclude(pts[i].fX + 0.1f, pts[i].fY + 0.1f); |
| } |
| if (!SkRect::Intersects(target, bounds)) { |
| continue; |
| } |
| if (closed) { |
| tiny.moveTo(pts[0].fX, pts[0].fY); |
| closed = false; |
| } else if (pts[0] != lastPt) { |
| tiny.lineTo(pts[0].fX, pts[0].fY); |
| } |
| switch (verb) { |
| case SkPath::kLine_Verb: |
| tiny.lineTo(pts[1].fX, pts[1].fY); |
| lastPt = pts[1]; |
| break; |
| case SkPath::kQuad_Verb: |
| tiny.quadTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY); |
| lastPt = pts[2]; |
| break; |
| case SkPath::kCubic_Verb: |
| tiny.cubicTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, pts[3].fX, pts[3].fY); |
| lastPt = pts[3]; |
| break; |
| default: |
| SkDEBUGFAIL("bad verb"); |
| } |
| } |
| if (!closed) { |
| tiny.close(); |
| } |
| if (show) { |
| showPath(tiny, NULL); |
| SkDebugf("simplified:\n"); |
| } |
| testSimplifyx(tiny); |
| } |
| #endif |
| |
| #if 0 |
| static void tryRonco(const SkPath& path) { |
| int divMax = 64; |
| int divMin = 1; |
| int xDivMin = 0; |
| int yDivMin = 0; |
| bool allYs = true; |
| bool allXs = true; |
| if (1) { |
| divMax = divMin = 64; |
| xDivMin = 11; |
| yDivMin = 0; |
| allXs = true; |
| allYs = true; |
| } |
| for (int divs = divMax; divs >= divMin; divs /= 2) { |
| SkDebugf("divs=%d\n",divs); |
| const SkRect& overall = path.getBounds(); |
| SkScalar cellWidth = overall.width() / divs * 2; |
| SkScalar cellHeight = overall.height() / divs * 2; |
| SkRect target; |
| int xDivMax = divMax == divMin && !allXs ? xDivMin + 1 : divs; |
| int yDivMax = divMax == divMin && !allYs ? yDivMin + 1 : divs; |
| for (int xDiv = xDivMin; xDiv < xDivMax; ++xDiv) { |
| SkDebugf("xDiv=%d\n",xDiv); |
| for (int yDiv = yDivMin; yDiv < yDivMax; ++yDiv) { |
| SkDebugf("yDiv=%d\n",yDiv); |
| target.setXYWH(overall.fLeft + (overall.width() - cellWidth) * xDiv / divs, |
| overall.fTop + (overall.height() - cellHeight) * yDiv / divs, |
| cellWidth, cellHeight); |
| tryRoncoOnce(path, target, divMax == divMin); |
| } |
| } |
| } |
| } |
| #endif |
| |
| static bool drawLetters(SkCanvas* canvas, int step, bool useOld) |
| { |
| SkPath path; |
| const int width = 640; |
| const int height = 480; |
| const char testStr[] = "Merge"; |
| const int testStrLen = sizeof(testStr) - 1; |
| SkPoint textPos[testStrLen]; |
| SkScalar widths[testStrLen]; |
| SkPaint paint; |
| paint.setTextSize(40); |
| paint.setAntiAlias(true); |
| paint.getTextWidths(testStr, testStrLen, widths, NULL); |
| SkScalar running = 0; |
| for (int x = 0; x < testStrLen; ++x) { |
| SkScalar width = widths[x]; |
| widths[x] = running; |
| running += width; |
| } |
| SkScalar bias = (width - widths[testStrLen - 1]) / 2; |
| for (int x = 0; x < testStrLen; ++x) { |
| textPos[x].fX = bias + widths[x]; |
| textPos[x].fY = height / 2; |
| } |
| paint.setTextSize(40 + step / 100.0f); |
| #if 0 |
| bool oneShot = false; |
| for (int mask = 0; mask < 1 << testStrLen; ++mask) { |
| char maskStr[testStrLen]; |
| #if 1 |
| mask = 12; |
| oneShot = true; |
| #endif |
| SkDebugf("mask=%d\n", mask); |
| for (int letter = 0; letter < testStrLen; ++letter) { |
| maskStr[letter] = mask & (1 << letter) ? testStr[letter] : ' '; |
| } |
| paint.getPosTextPath(maskStr, testStrLen, textPos, &path); |
| // showPath(path, NULL); |
| // SkDebugf("%d simplified:\n", mask); |
| tryRonco(path); |
| // testSimplifyx(path); |
| if (oneShot) { |
| break; |
| } |
| } |
| #endif |
| paint.getPosTextPath(testStr, testStrLen, textPos, &path); |
| #if 0 |
| tryRonco(path); |
| SkDebugf("RoncoDone!\n"); |
| #endif |
| #if 0 |
| showPath(path, NULL); |
| SkDebugf("simplified:\n"); |
| #endif |
| return drawPaths(canvas, path, false); |
| } |
| |
| static bool (*drawDemos[])(SkCanvas* , int , bool ) = { |
| drawStars, |
| drawCircles, |
| drawLetters, |
| }; |
| |
| static size_t drawDemosCount = sizeof(drawDemos) / sizeof(drawDemos[0]); |
| |
| static bool (*firstTest)(SkCanvas* , int , bool) = drawStars; |
| |
| |
| bool DrawEdgeDemo(SkCanvas* canvas, int step, bool useOld) { |
| size_t index = 0; |
| if (firstTest) { |
| while (index < drawDemosCount && drawDemos[index] != firstTest) { |
| ++index; |
| } |
| } |
| return (*drawDemos[index])(canvas, step, useOld); |
| } |
