#include #include "SkPath.h" #include "SkParse.h" #include "SkPoint.h" #include "SkUtils.h" #define QUADRATIC_APPROXIMATION 0 const char logoStr[] = "" "" "" "" "" "" "" "" ; size_t logoStrLen = sizeof(logoStr); #if QUADRATIC_APPROXIMATION //////////////////////////////////////////////////////////////////////////////////// //functions to approximate a cubic using two quadratics // midPt sets the first argument to be the midpoint of the other two // it is used by quadApprox static inline void midPt(SkPoint& dest,const SkPoint& a,const SkPoint& b) { dest.set(SkScalarAve(a.fX, b.fX),SkScalarAve(a.fY, b.fY)); } // quadApprox - makes an approximation, which we hope is faster static void quadApprox(SkPath &fPath, const SkPoint &p0, const SkPoint &p1, const SkPoint &p2) { //divide the cubic up into two cubics, then convert them into quadratics //define our points SkPoint c,j,k,l,m,n,o,p,q, mid; fPath.getLastPt(&c); midPt(j, p0, c); midPt(k, p0, p1); midPt(l, p1, p2); midPt(o, j, k); midPt(p, k, l); midPt(q, o, p); //compute the first half m.set(SkScalarHalf(3*j.fX - c.fX), SkScalarHalf(3*j.fY - c.fY)); n.set(SkScalarHalf(3*o.fX -q.fX), SkScalarHalf(3*o.fY - q.fY)); midPt(mid,m,n); fPath.quadTo(mid,q); c = q; //compute the second half m.set(SkScalarHalf(3*p.fX - c.fX), SkScalarHalf(3*p.fY - c.fY)); n.set(SkScalarHalf(3*l.fX -p2.fX),SkScalarHalf(3*l.fY -p2.fY)); midPt(mid,m,n); fPath.quadTo(mid,p2); } #endif static inline bool is_between(int c, int min, int max) { return (unsigned)(c - min) <= (unsigned)(max - min); } static inline bool is_ws(int c) { return is_between(c, 1, 32); } static inline bool is_digit(int c) { return is_between(c, '0', '9'); } static inline bool is_sep(int c) { return is_ws(c) || c == ','; } static const char* skip_ws(const char str[]) { SkASSERT(str); while (is_ws(*str)) str++; return str; } static const char* skip_sep(const char str[]) { SkASSERT(str); while (is_sep(*str)) str++; return str; } static const char* find_points(const char str[], SkPoint value[], int count, bool isRelative, SkPoint* relative) { str = SkParse::FindScalars(str, &value[0].fX, count * 2); if (isRelative) { for (int index = 0; index < count; index++) { value[index].fX += relative->fX; value[index].fY += relative->fY; } } return str; } static const char* find_scalar(const char str[], SkScalar* value, bool isRelative, SkScalar relative) { str = SkParse::FindScalar(str, value); if (isRelative) *value += relative; return str; } static void showPathContour(SkPath::Iter& iter) { uint8_t verb; SkPoint pts[4]; while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { switch (verb) { case SkPath::kMove_Verb: SkDebugf("path.moveTo(%1.9gf,%1.9gf);\n", pts[0].fX, pts[0].fY); continue; case SkPath::kLine_Verb: SkDebugf("path.lineTo(%1.9gf,%1.9gf);\n", pts[1].fX, pts[1].fY); break; case SkPath::kQuad_Verb: SkDebugf("path.quadTo(%1.9gf,%1.9gf, %1.9gf,%1.9gf);\n", pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY); break; case SkPath::kCubic_Verb: SkDebugf("path.cubicTo(%1.9gf,%1.9gf, %1.9gf,%1.9gf, %1.9gf,%1.9gf);\n", pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, pts[3].fX, pts[3].fY); break; case SkPath::kClose_Verb: SkDebugf("path.close();\n"); break; default: SkDEBUGFAIL("bad verb"); return; } } } static void showPath(const SkPath& path) { SkPath::Iter iter(path, true); int rectCount = path.isRectContours() ? path.rectContours(NULL, NULL) : 0; if (rectCount > 0) { SkTDArray rects; SkTDArray directions; rects.setCount(rectCount); directions.setCount(rectCount); path.rectContours(rects.begin(), directions.begin()); for (int contour = 0; contour < rectCount; ++contour) { const SkRect& rect = rects[contour]; SkDebugf("path.addRect(%1.9g, %1.9g, %1.9g, %1.9g, %s);\n", rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, directions[contour] == SkPath::kCCW_Direction ? "SkPath::kCCW_Direction" : "SkPath::kCW_Direction"); } return; } iter.setPath(path, true); showPathContour(iter); } static const char* parsePath(const char* data) { SkPath fPath; SkPoint f = {0, 0}; SkPoint c = {0, 0}; SkPoint lastc = {0, 0}; SkPoint points[3]; char op = '\0'; char previousOp = '\0'; bool relative = false; do { data = skip_ws(data); if (data[0] == '\0') break; char ch = data[0]; if (is_digit(ch) || ch == '-' || ch == '+') { if (op == '\0') { SkASSERT(0); return 0; } } else { op = ch; relative = false; if (islower(op)) { op = (char) toupper(op); relative = true; } data++; data = skip_sep(data); } switch (op) { case 'M': data = find_points(data, points, 1, relative, &c); fPath.moveTo(points[0]); op = 'L'; c = points[0]; break; case 'L': data = find_points(data, points, 1, relative, &c); fPath.lineTo(points[0]); c = points[0]; break; case 'H': { SkScalar x; data = find_scalar(data, &x, relative, c.fX); fPath.lineTo(x, c.fY); c.fX = x; } break; case 'V': { SkScalar y; data = find_scalar(data, &y, relative, c.fY); fPath.lineTo(c.fX, y); c.fY = y; } break; case 'C': data = find_points(data, points, 3, relative, &c); goto cubicCommon; case 'S': data = find_points(data, &points[1], 2, relative, &c); points[0] = c; if (previousOp == 'C' || previousOp == 'S') { points[0].fX -= lastc.fX - c.fX; points[0].fY -= lastc.fY - c.fY; } cubicCommon: // if (data[0] == '\0') // return; #if QUADRATIC_APPROXIMATION quadApprox(fPath, points[0], points[1], points[2]); #else //this way just does a boring, slow old cubic fPath.cubicTo(points[0], points[1], points[2]); #endif //if we are using the quadApprox, lastc is what it would have been if we had used //cubicTo lastc = points[1]; c = points[2]; break; case 'Q': // Quadratic Bezier Curve data = find_points(data, points, 2, relative, &c); goto quadraticCommon; case 'T': data = find_points(data, &points[1], 1, relative, &c); points[0] = points[1]; if (previousOp == 'Q' || previousOp == 'T') { points[0].fX = c.fX * 2 - lastc.fX; points[0].fY = c.fY * 2 - lastc.fY; } quadraticCommon: fPath.quadTo(points[0], points[1]); lastc = points[0]; c = points[1]; break; case 'Z': fPath.close(); #if 0 // !!! still a bug? if (fPath.isEmpty() && (f.fX != 0 || f.fY != 0)) { c.fX -= SkScalar.Epsilon; // !!! enough? fPath.moveTo(c); fPath.lineTo(f); fPath.close(); } #endif c = f; op = '\0'; break; case '~': { SkPoint args[2]; data = find_points(data, args, 2, false, NULL); fPath.moveTo(args[0].fX, args[0].fY); fPath.lineTo(args[1].fX, args[1].fY); } break; default: SkASSERT(0); return 0; } if (previousOp == 0) f = c; previousOp = op; } while (data[0] != '"'); showPath(fPath); return data; } const char pathPrefix[] = "drawPath(path, paint);\n"); SkASSERT(strncmp(data, "\"/>", 3) == 0); data += 3; } }