#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);
}