cobalt / cobalt / 2a8c847d785c1602f60915c8e0112e0aec6a15a5 / . / src / third_party / skia / include / core / SkPath.h

/* | |

* Copyright 2006 The Android Open Source Project | |

* | |

* Use of this source code is governed by a BSD-style license that can be | |

* found in the LICENSE file. | |

*/ | |

#ifndef SkPath_DEFINED | |

#define SkPath_DEFINED | |

#include "SkMatrix.h" | |

#include "../private/SkPathRef.h" | |

class SkAutoPathBoundsUpdate; | |

class SkRRect; | |

class SkWStream; | |

/** \class SkPath | |

The SkPath class encapsulates compound (multiple contour) geometric paths | |

consisting of straight line segments, quadratic curves, and cubic curves. | |

SkPath is not thread safe unless you've first called SkPath::updateBoundsCache(). | |

*/ | |

class SK_API SkPath { | |

public: | |

enum Direction { | |

/** clockwise direction for adding closed contours */ | |

kCW_Direction, | |

/** counter-clockwise direction for adding closed contours */ | |

kCCW_Direction, | |

}; | |

SkPath(); | |

SkPath(const SkPath& path); | |

~SkPath(); | |

SkPath& operator=(const SkPath& path); | |

// mac chromium dbg requires SK_API to make operator== visible | |

friend SK_API bool operator==(const SkPath& a, const SkPath& b); | |

friend bool operator!=(const SkPath& a, const SkPath& b) { | |

return !(a == b); | |

} | |

/** Return true if the paths contain an equal array of verbs and weights. Paths | |

* with equal verb counts can be readily interpolated. If the paths contain one | |

* or more conics, the conics' weights must also match. | |

* | |

* @param compare The path to compare. | |

* | |

* @return true if the paths have the same verbs and weights. | |

*/ | |

bool isInterpolatable(const SkPath& compare) const; | |

/** Interpolate between two paths with same-sized point arrays. | |

* The out path contains the verbs and weights of this path. | |

* The out points are a weighted average of this path and the ending path. | |

* | |

* @param ending The path to interpolate between. | |

* @param weight The weight, from 0 to 1. The output points are set to | |

* (this->points * weight) + ending->points * (1 - weight). | |

* @return true if the paths could be interpolated. | |

*/ | |

bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const; | |

#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK | |

/** Returns true if the caller is the only owner of the underlying path data */ | |

bool unique() const { return fPathRef->unique(); } | |

#endif | |

enum FillType { | |

/** Specifies that "inside" is computed by a non-zero sum of signed | |

edge crossings | |

*/ | |

kWinding_FillType, | |

/** Specifies that "inside" is computed by an odd number of edge | |

crossings | |

*/ | |

kEvenOdd_FillType, | |

/** Same as Winding, but draws outside of the path, rather than inside | |

*/ | |

kInverseWinding_FillType, | |

/** Same as EvenOdd, but draws outside of the path, rather than inside | |

*/ | |

kInverseEvenOdd_FillType | |

}; | |

/** Return the path's fill type. This is used to define how "inside" is | |

computed. The default value is kWinding_FillType. | |

@return the path's fill type | |

*/ | |

FillType getFillType() const { return (FillType)fFillType; } | |

/** Set the path's fill type. This is used to define how "inside" is | |

computed. The default value is kWinding_FillType. | |

@param ft The new fill type for this path | |

*/ | |

void setFillType(FillType ft) { | |

fFillType = SkToU8(ft); | |

} | |

/** Returns true if the filltype is one of the Inverse variants */ | |

bool isInverseFillType() const { return IsInverseFillType((FillType)fFillType); } | |

/** | |

* Toggle between inverse and normal filltypes. This reverse the return | |

* value of isInverseFillType() | |

*/ | |

void toggleInverseFillType() { | |

fFillType ^= 2; | |

} | |

enum Convexity { | |

kUnknown_Convexity, | |

kConvex_Convexity, | |

kConcave_Convexity | |

}; | |

/** | |

* Return the path's convexity, as stored in the path. If it is currently unknown, | |

* then this function will attempt to compute the convexity (and cache the result). | |

*/ | |

Convexity getConvexity() const { | |

if (kUnknown_Convexity != fConvexity) { | |

return static_cast<Convexity>(fConvexity); | |

} else { | |

return this->internalGetConvexity(); | |

} | |

} | |

/** | |

* Return the currently cached value for convexity, even if that is set to | |

* kUnknown_Convexity. Note: getConvexity() will automatically call | |

* ComputeConvexity and cache its return value if the current setting is | |

* kUnknown. | |

*/ | |

Convexity getConvexityOrUnknown() const { return (Convexity)fConvexity; } | |

/** | |

* Store a convexity setting in the path. There is no automatic check to | |

* see if this value actually agrees with the return value that would be | |

* computed by getConvexity(). | |

* | |

* Note: even if this is set to a "known" value, if the path is later | |

* changed (e.g. lineTo(), addRect(), etc.) then the cached value will be | |

* reset to kUnknown_Convexity. | |

*/ | |

void setConvexity(Convexity convexity); | |

/** | |

* Returns true if the path is flagged as being convex. This is not a | |

* confirmed by any analysis, it is just the value set earlier. | |

*/ | |

bool isConvex() const { | |

return kConvex_Convexity == this->getConvexity(); | |

} | |

/** | |

* Set the isConvex flag to true or false. Convex paths may draw faster if | |

* this flag is set, though setting this to true on a path that is in fact | |

* not convex can give undefined results when drawn. Paths default to | |

* isConvex == false | |

*/ | |

SK_ATTR_DEPRECATED("use setConvexity") | |

void setIsConvex(bool isConvex) { | |

this->setConvexity(isConvex ? kConvex_Convexity : kConcave_Convexity); | |

} | |

/** Returns true if the path is an oval. | |

* | |

* @param rect returns the bounding rect of this oval. It's a circle | |

* if the height and width are the same. | |

* @param dir is the oval CCW (or CW if false). | |

* @param start indicates where the contour starts on the oval (see | |

* SkPath::addOval for intepretation of the index). | |

* @return true if this path is an oval. | |

* Tracking whether a path is an oval is considered an | |

* optimization for performance and so some paths that are in | |

* fact ovals can report false. | |

*/ | |

bool isOval(SkRect* rect, Direction* dir = nullptr, | |

unsigned* start = nullptr) const { | |

bool isCCW = false; | |

bool result = fPathRef->isOval(rect, &isCCW, start); | |

if (dir && result) { | |

*dir = isCCW ? kCCW_Direction : kCW_Direction; | |

} | |

return result; | |

} | |

/** Returns true if the path is a round rect. | |

* | |

* @param rrect Returns the bounding rect and radii of this round rect. | |

* @param dir is the rrect CCW (or CW if false). | |

* @param start indicates where the contour starts on the rrect (see | |

* SkPath::addRRect for intepretation of the index). | |

* | |

* @return true if this path is a round rect. | |

* Tracking whether a path is a round rect is considered an | |

* optimization for performance and so some paths that are in | |

* fact round rects can report false. | |

*/ | |

bool isRRect(SkRRect* rrect, Direction* dir = nullptr, | |

unsigned* start = nullptr) const { | |

bool isCCW = false; | |

bool result = fPathRef->isRRect(rrect, &isCCW, start); | |

if (dir && result) { | |

*dir = isCCW ? kCCW_Direction : kCW_Direction; | |

} | |

return result; | |

} | |

/** Clear any lines and curves from the path, making it empty. This frees up | |

internal storage associated with those segments. | |

On Android, does not change fSourcePath. | |

*/ | |

void reset(); | |

/** Similar to reset(), in that all lines and curves are removed from the | |

path. However, any internal storage for those lines/curves is retained, | |

making reuse of the path potentially faster. | |

On Android, does not change fSourcePath. | |

*/ | |

void rewind(); | |

/** Returns true if the path is empty (contains no lines or curves) | |

@return true if the path is empty (contains no lines or curves) | |

*/ | |

bool isEmpty() const { | |

SkDEBUGCODE(this->validate();) | |

return 0 == fPathRef->countVerbs(); | |

} | |

/** Return true if the last contour of this path ends with a close verb. | |

*/ | |

bool isLastContourClosed() const; | |

/** | |

* Returns true if all of the points in this path are finite, meaning there | |

* are no infinities and no NaNs. | |

*/ | |

bool isFinite() const { | |

SkDEBUGCODE(this->validate();) | |

return fPathRef->isFinite(); | |

} | |

/** Returns true if the path is volatile (i.e. should not be cached by devices.) | |

*/ | |

bool isVolatile() const { | |

return SkToBool(fIsVolatile); | |

} | |

/** Specify whether this path is volatile. Paths are not volatile by | |

default. Temporary paths that are discarded or modified after use should be | |

marked as volatile. This provides a hint to the device that the path | |

should not be cached. Providing this hint when appropriate can | |

improve performance by avoiding unnecessary overhead and resource | |

consumption on the device. | |

*/ | |

void setIsVolatile(bool isVolatile) { | |

fIsVolatile = isVolatile; | |

} | |

/** Test a line for zero length | |

@return true if the line is of zero length; otherwise false. | |

*/ | |

static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact) { | |

return exact ? p1 == p2 : p1.equalsWithinTolerance(p2); | |

} | |

/** Test a quad for zero length | |

@return true if the quad is of zero length; otherwise false. | |

*/ | |

static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2, | |

const SkPoint& p3, bool exact) { | |

return exact ? p1 == p2 && p2 == p3 : p1.equalsWithinTolerance(p2) && | |

p2.equalsWithinTolerance(p3); | |

} | |

/** Test a cubic curve for zero length | |

@return true if the cubic is of zero length; otherwise false. | |

*/ | |

static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2, | |

const SkPoint& p3, const SkPoint& p4, bool exact) { | |

return exact ? p1 == p2 && p2 == p3 && p3 == p4 : p1.equalsWithinTolerance(p2) && | |

p2.equalsWithinTolerance(p3) && | |

p3.equalsWithinTolerance(p4); | |

} | |

/** | |

* Returns true if the path specifies a single line (i.e. it contains just | |

* a moveTo and a lineTo). If so, and line[] is not null, it sets the 2 | |

* points in line[] to the end-points of the line. If the path is not a | |

* line, returns false and ignores line[]. | |

*/ | |

bool isLine(SkPoint line[2]) const; | |

/** Return the number of points in the path | |

*/ | |

int countPoints() const; | |

/** Return the point at the specified index. If the index is out of range | |

(i.e. is not 0 <= index < countPoints()) then the returned coordinates | |

will be (0,0) | |

*/ | |

SkPoint getPoint(int index) const; | |

/** Returns the number of points in the path. Up to max points are copied. | |

@param points If not null, receives up to max points | |

@param max The maximum number of points to copy into points | |

@return the actual number of points in the path | |

*/ | |

int getPoints(SkPoint points[], int max) const; | |

/** Return the number of verbs in the path | |

*/ | |

int countVerbs() const; | |

/** Returns the number of verbs in the path. Up to max verbs are copied. The | |

verbs are copied as one byte per verb. | |

@param verbs If not null, receives up to max verbs | |

@param max The maximum number of verbs to copy into verbs | |

@return the actual number of verbs in the path | |

*/ | |

int getVerbs(uint8_t verbs[], int max) const; | |

//! Swap contents of this and other. Guaranteed not to throw | |

void swap(SkPath& other); | |

/** | |

* Returns the bounds of the path's points. If the path contains zero points/verbs, this | |

* will return the "empty" rect [0, 0, 0, 0]. | |

* Note: this bounds may be larger than the actual shape, since curves | |

* do not extend as far as their control points. Additionally this bound encompases all points, | |

* even isolated moveTos either preceeding or following the last non-degenerate contour. | |

*/ | |

const SkRect& getBounds() const { | |

return fPathRef->getBounds(); | |

} | |

/** Calling this will, if the internal cache of the bounds is out of date, | |

update it so that subsequent calls to getBounds will be instantaneous. | |

This also means that any copies or simple transformations of the path | |

will inherit the cached bounds. | |

*/ | |

void updateBoundsCache() const { | |

// for now, just calling getBounds() is sufficient | |

this->getBounds(); | |

} | |

/** | |

* Computes a bounds that is conservatively "snug" around the path. This assumes that the | |

* path will be filled. It does not attempt to collapse away contours that are logically | |

* empty (e.g. moveTo(x, y) + lineTo(x, y)) but will include them in the calculation. | |

* | |

* It differs from getBounds() in that it will look at the snug bounds of curves, whereas | |

* getBounds() just returns the bounds of the control-points. Thus computing this may be | |

* slower than just calling getBounds(). | |

* | |

* If the path is empty (i.e. no points or verbs), it will return SkRect::MakeEmpty(). | |

*/ | |

SkRect computeTightBounds() const; | |

/** | |

* Does a conservative test to see whether a rectangle is inside a path. Currently it only | |

* will ever return true for single convex contour paths. The empty-status of the rect is not | |

* considered (e.g. a rect that is a point can be inside a path). Points or line segments where | |

* the rect edge touches the path border are not considered containment violations. | |

*/ | |

bool conservativelyContainsRect(const SkRect& rect) const; | |

// Construction methods | |

/** Hint to the path to prepare for adding more points. This can allow the | |

path to more efficiently grow its storage. | |

@param extraPtCount The number of extra points the path should | |

preallocate for. | |

*/ | |

void incReserve(unsigned extraPtCount); | |

/** Set the beginning of the next contour to the point (x,y). | |

@param x The x-coordinate of the start of a new contour | |

@param y The y-coordinate of the start of a new contour | |

*/ | |

void moveTo(SkScalar x, SkScalar y); | |

/** Set the beginning of the next contour to the point | |

@param p The start of a new contour | |

*/ | |

void moveTo(const SkPoint& p) { | |

this->moveTo(p.fX, p.fY); | |

} | |

/** Set the beginning of the next contour relative to the last point on the | |

previous contour. If there is no previous contour, this is treated the | |

same as moveTo(). | |

@param dx The amount to add to the x-coordinate of the end of the | |

previous contour, to specify the start of a new contour | |

@param dy The amount to add to the y-coordinate of the end of the | |

previous contour, to specify the start of a new contour | |

*/ | |

void rMoveTo(SkScalar dx, SkScalar dy); | |

/** Add a line from the last point to the specified point (x,y). If no | |

moveTo() call has been made for this contour, the first point is | |

automatically set to (0,0). | |

@param x The x-coordinate of the end of a line | |

@param y The y-coordinate of the end of a line | |

*/ | |

void lineTo(SkScalar x, SkScalar y); | |

/** Add a line from the last point to the specified point. If no moveTo() | |

call has been made for this contour, the first point is automatically | |

set to (0,0). | |

@param p The end of a line | |

*/ | |

void lineTo(const SkPoint& p) { | |

this->lineTo(p.fX, p.fY); | |

} | |

/** Same as lineTo, but the coordinates are considered relative to the last | |

point on this contour. If there is no previous point, then a moveTo(0,0) | |

is inserted automatically. | |

@param dx The amount to add to the x-coordinate of the previous point | |

on this contour, to specify a line | |

@param dy The amount to add to the y-coordinate of the previous point | |

on this contour, to specify a line | |

*/ | |

void rLineTo(SkScalar dx, SkScalar dy); | |

/** Add a quadratic bezier from the last point, approaching control point | |

(x1,y1), and ending at (x2,y2). If no moveTo() call has been made for | |

this contour, the first point is automatically set to (0,0). | |

@param x1 The x-coordinate of the control point on a quadratic curve | |

@param y1 The y-coordinate of the control point on a quadratic curve | |

@param x2 The x-coordinate of the end point on a quadratic curve | |

@param y2 The y-coordinate of the end point on a quadratic curve | |

*/ | |

void quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2); | |

/** Add a quadratic bezier from the last point, approaching control point | |

p1, and ending at p2. If no moveTo() call has been made for this | |

contour, the first point is automatically set to (0,0). | |

@param p1 The control point on a quadratic curve | |

@param p2 The end point on a quadratic curve | |

*/ | |

void quadTo(const SkPoint& p1, const SkPoint& p2) { | |

this->quadTo(p1.fX, p1.fY, p2.fX, p2.fY); | |

} | |

/** Same as quadTo, but the coordinates are considered relative to the last | |

point on this contour. If there is no previous point, then a moveTo(0,0) | |

is inserted automatically. | |

@param dx1 The amount to add to the x-coordinate of the last point on | |

this contour, to specify the control point of a quadratic curve | |

@param dy1 The amount to add to the y-coordinate of the last point on | |

this contour, to specify the control point of a quadratic curve | |

@param dx2 The amount to add to the x-coordinate of the last point on | |

this contour, to specify the end point of a quadratic curve | |

@param dy2 The amount to add to the y-coordinate of the last point on | |

this contour, to specify the end point of a quadratic curve | |

*/ | |

void rQuadTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2); | |

void conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, | |

SkScalar w); | |

void conicTo(const SkPoint& p1, const SkPoint& p2, SkScalar w) { | |

this->conicTo(p1.fX, p1.fY, p2.fX, p2.fY, w); | |

} | |

void rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, | |

SkScalar w); | |

/** Add a cubic bezier from the last point, approaching control points | |

(x1,y1) and (x2,y2), and ending at (x3,y3). If no moveTo() call has been | |

made for this contour, the first point is automatically set to (0,0). | |

@param x1 The x-coordinate of the 1st control point on a cubic curve | |

@param y1 The y-coordinate of the 1st control point on a cubic curve | |

@param x2 The x-coordinate of the 2nd control point on a cubic curve | |

@param y2 The y-coordinate of the 2nd control point on a cubic curve | |

@param x3 The x-coordinate of the end point on a cubic curve | |

@param y3 The y-coordinate of the end point on a cubic curve | |

*/ | |

void cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, | |

SkScalar x3, SkScalar y3); | |

/** Add a cubic bezier from the last point, approaching control points p1 | |

and p2, and ending at p3. If no moveTo() call has been made for this | |

contour, the first point is automatically set to (0,0). | |

@param p1 The 1st control point on a cubic curve | |

@param p2 The 2nd control point on a cubic curve | |

@param p3 The end point on a cubic curve | |

*/ | |

void cubicTo(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3) { | |

this->cubicTo(p1.fX, p1.fY, p2.fX, p2.fY, p3.fX, p3.fY); | |

} | |

/** Same as cubicTo, but the coordinates are considered relative to the | |

current point on this contour. If there is no previous point, then a | |

moveTo(0,0) is inserted automatically. | |

@param x1 The amount to add to the x-coordinate of the last point on | |

this contour, to specify the 1st control point of a cubic curve | |

@param y1 The amount to add to the y-coordinate of the last point on | |

this contour, to specify the 1st control point of a cubic curve | |

@param x2 The amount to add to the x-coordinate of the last point on | |

this contour, to specify the 2nd control point of a cubic curve | |

@param y2 The amount to add to the y-coordinate of the last point on | |

this contour, to specify the 2nd control point of a cubic curve | |

@param x3 The amount to add to the x-coordinate of the last point on | |

this contour, to specify the end point of a cubic curve | |

@param y3 The amount to add to the y-coordinate of the last point on | |

this contour, to specify the end point of a cubic curve | |

*/ | |

void rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, | |

SkScalar x3, SkScalar y3); | |

/** | |

* Append the specified arc to the path. If the start of the arc is different from the path's | |

* current last point, then an automatic lineTo() is added to connect the current contour | |

* to the start of the arc. However, if the path is empty, then we call moveTo() with | |

* the first point of the arc. The sweep angle is treated mod 360. | |

* | |

* @param oval The bounding oval defining the shape and size of the arc | |

* @param startAngle Starting angle (in degrees) where the arc begins | |

* @param sweepAngle Sweep angle (in degrees) measured clockwise. This is treated mod 360. | |

* @param forceMoveTo If true, always begin a new contour with the arc | |

*/ | |

void arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo); | |

/** | |

* Append a line and arc to the current path. This is the same as the PostScript call "arct". | |

*/ | |

void arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius); | |

/** Append a line and arc to the current path. This is the same as the | |

PostScript call "arct". | |

*/ | |

void arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius) { | |

this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius); | |

} | |

enum ArcSize { | |

/** the smaller of the two possible SVG arcs. */ | |

kSmall_ArcSize, | |

/** the larger of the two possible SVG arcs. */ | |

kLarge_ArcSize, | |

}; | |

/** | |

* Append an elliptical arc from the current point in the format used by SVG. | |

* The center of the ellipse is computed to satisfy the constraints below. | |

* | |

* @param rx,ry The radii in the x and y directions respectively. | |

* @param xAxisRotate The angle in degrees relative to the x-axis. | |

* @param largeArc Determines whether the smallest or largest arc possible | |

* is drawn. | |

* @param sweep Determines if the arc should be swept in an anti-clockwise or | |

* clockwise direction. Note that this enum value is opposite the SVG | |

* arc sweep value. | |

* @param x,y The destination coordinates. | |

*/ | |

void arcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, | |

Direction sweep, SkScalar x, SkScalar y); | |

void arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep, | |

const SkPoint xy) { | |

this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, sweep, xy.fX, xy.fY); | |

} | |

/** Same as arcTo format used by SVG, but the destination coordinate is relative to the | |

* last point on this contour. If there is no previous point, then a | |

* moveTo(0,0) is inserted automatically. | |

* | |

* @param rx,ry The radii in the x and y directions respectively. | |

* @param xAxisRotate The angle in degrees relative to the x-axis. | |

* @param largeArc Determines whether the smallest or largest arc possible | |

* is drawn. | |

* @param sweep Determines if the arc should be swept in an anti-clockwise or | |

* clockwise direction. Note that this enum value is opposite the SVG | |

* arc sweep value. | |

* @param dx,dy The destination coordinates relative to the last point. | |

*/ | |

void rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, | |

Direction sweep, SkScalar dx, SkScalar dy); | |

/** Close the current contour. If the current point is not equal to the | |

first point of the contour, a line segment is automatically added. | |

*/ | |

void close(); | |

/** | |

* Returns whether or not a fill type is inverted | |

* | |

* kWinding_FillType -> false | |

* kEvenOdd_FillType -> false | |

* kInverseWinding_FillType -> true | |

* kInverseEvenOdd_FillType -> true | |

*/ | |

static bool IsInverseFillType(FillType fill) { | |

static_assert(0 == kWinding_FillType, "fill_type_mismatch"); | |

static_assert(1 == kEvenOdd_FillType, "fill_type_mismatch"); | |

static_assert(2 == kInverseWinding_FillType, "fill_type_mismatch"); | |

static_assert(3 == kInverseEvenOdd_FillType, "fill_type_mismatch"); | |

return (fill & 2) != 0; | |

} | |

/** | |

* Returns the equivalent non-inverted fill type to the given fill type | |

* | |

* kWinding_FillType -> kWinding_FillType | |

* kEvenOdd_FillType -> kEvenOdd_FillType | |

* kInverseWinding_FillType -> kWinding_FillType | |

* kInverseEvenOdd_FillType -> kEvenOdd_FillType | |

*/ | |

static FillType ConvertToNonInverseFillType(FillType fill) { | |

static_assert(0 == kWinding_FillType, "fill_type_mismatch"); | |

static_assert(1 == kEvenOdd_FillType, "fill_type_mismatch"); | |

static_assert(2 == kInverseWinding_FillType, "fill_type_mismatch"); | |

static_assert(3 == kInverseEvenOdd_FillType, "fill_type_mismatch"); | |

return (FillType)(fill & 1); | |

} | |

/** | |

* Chop a conic into N quads, stored continguously in pts[], where | |

* N = 1 << pow2. The amount of storage needed is (1 + 2 * N) | |

*/ | |

static int ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2, | |

SkScalar w, SkPoint pts[], int pow2); | |

/** | |

* Returns true if the path specifies a rectangle. | |

* | |

* If this returns false, then all output parameters are ignored, and left | |

* unchanged. If this returns true, then each of the output parameters | |

* are checked for NULL. If they are not, they return their value. | |

* | |

* @param rect If not null, set to the bounds of the rectangle. | |

* Note : this bounds may be smaller than the path's bounds, since it is just | |

* the bounds of the "drawable" parts of the path. e.g. a trailing MoveTo would | |

* be ignored in this rect, but not by the path's bounds | |

* @param isClosed If not null, set to true if the path is closed | |

* @param direction If not null, set to the rectangle's direction | |

* @return true if the path specifies a rectangle | |

*/ | |

bool isRect(SkRect* rect, bool* isClosed = NULL, Direction* direction = NULL) const; | |

/** Returns true if the path specifies a pair of nested rectangles, or would draw a | |

pair of nested rectangles when filled. If so, and if | |

rect is not null, set rect[0] to the outer rectangle and rect[1] to the inner | |

rectangle. If so, and dirs is not null, set dirs[0] to the direction of | |

the outer rectangle and dirs[1] to the direction of the inner rectangle. If | |

the path does not specify a pair of nested rectangles, return | |

false and ignore rect and dirs. | |

@param rect If not null, returns the path as a pair of nested rectangles | |

@param dirs If not null, returns the direction of the rects | |

@return true if the path describes a pair of nested rectangles | |

*/ | |

bool isNestedFillRects(SkRect rect[2], Direction dirs[2] = NULL) const; | |

/** | |

* Add a closed rectangle contour to the path | |

* @param rect The rectangle to add as a closed contour to the path | |

* @param dir The direction to wind the rectangle's contour. | |

* | |

* Note: the contour initial point index is 0 (as defined below). | |

*/ | |

void addRect(const SkRect& rect, Direction dir = kCW_Direction); | |

/** | |

* Add a closed rectangle contour to the path | |

* @param rect The rectangle to add as a closed contour to the path | |

* @param dir The direction to wind the rectangle's contour. | |

* @param start Initial point of the contour (initial moveTo), expressed as | |

* a corner index, starting in the upper-left position, clock-wise: | |

* | |

* 0 1 | |

* *-------* | |

* | | | |

* *-------* | |

* 3 2 | |

*/ | |

void addRect(const SkRect& rect, Direction dir, unsigned start); | |

/** | |

* Add a closed rectangle contour to the path | |

* | |

* @param left The left side of a rectangle to add as a closed contour | |

* to the path | |

* @param top The top of a rectangle to add as a closed contour to the | |

* path | |

* @param right The right side of a rectangle to add as a closed contour | |

* to the path | |

* @param bottom The bottom of a rectangle to add as a closed contour to | |

* the path | |

* @param dir The direction to wind the rectangle's contour. | |

* | |

* Note: the contour initial point index is 0 (as defined above). | |

*/ | |

void addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, | |

Direction dir = kCW_Direction); | |

/** | |

* Add a closed oval contour to the path | |

* | |

* @param oval The bounding oval to add as a closed contour to the path | |

* @param dir The direction to wind the oval's contour. | |

* | |

* Note: the contour initial point index is 1 (as defined below). | |

*/ | |

void addOval(const SkRect& oval, Direction dir = kCW_Direction); | |

/** | |

* Add a closed oval contour to the path | |

* | |

* @param oval The bounding oval to add as a closed contour to the path | |

* @param dir The direction to wind the oval's contour. | |

* @param start Initial point of the contour (initial moveTo), expressed | |

* as an ellipse vertex index, starting at the top, clock-wise | |

* (90/0/270/180deg order): | |

* | |

* 0 | |

* -*- | |

* | | | |

* 3 * * 1 | |

* | | | |

* -*- | |

* 2 | |

*/ | |

void addOval(const SkRect& oval, Direction dir, unsigned start); | |

/** | |

* Add a closed circle contour to the path. The circle contour begins at | |

* the right-most point (as though 1 were passed to addOval's 'start' param). | |

* | |

* @param x The x-coordinate of the center of a circle to add as a | |

* closed contour to the path | |

* @param y The y-coordinate of the center of a circle to add as a | |

* closed contour to the path | |

* @param radius The radius of a circle to add as a closed contour to the | |

* path | |

* @param dir The direction to wind the circle's contour. | |

*/ | |

void addCircle(SkScalar x, SkScalar y, SkScalar radius, | |

Direction dir = kCW_Direction); | |

/** Add the specified arc to the path as a new contour. | |

@param oval The bounds of oval used to define the size of the arc | |

@param startAngle Starting angle (in degrees) where the arc begins | |

@param sweepAngle Sweep angle (in degrees) measured clockwise | |

*/ | |

void addArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle); | |

/** | |

* Add a closed round-rectangle contour to the path | |

* @param rect The bounds of a round-rectangle to add as a closed contour | |

* @param rx The x-radius of the rounded corners on the round-rectangle | |

* @param ry The y-radius of the rounded corners on the round-rectangle | |

* @param dir The direction to wind the rectangle's contour. | |

*/ | |

void addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, | |

Direction dir = kCW_Direction); | |

/** | |

* Add a closed round-rectangle contour to the path. Each corner receives | |

* two radius values [X, Y]. The corners are ordered top-left, top-right, | |

* bottom-right, bottom-left. | |

* @param rect The bounds of a round-rectangle to add as a closed contour | |

* @param radii Array of 8 scalars, 4 [X,Y] pairs for each corner | |

* @param dir The direction to wind the rectangle's contour. | |

* Note: The radii here now go through the same constraint handling as the | |

* SkRRect radii (i.e., either radii at a corner being 0 implies a | |

* sqaure corner and oversized radii are proportionally scaled down). | |

*/ | |

void addRoundRect(const SkRect& rect, const SkScalar radii[], | |

Direction dir = kCW_Direction); | |

/** | |

* Add an SkRRect contour to the path | |

* @param rrect The rounded rect to add as a closed contour | |

* @param dir The winding direction for the new contour. | |

* | |

* Note: the contour initial point index is either 6 (for dir == kCW_Direction) | |

* or 7 (for dir == kCCW_Direction), as defined below. | |

* | |

*/ | |

void addRRect(const SkRRect& rrect, Direction dir = kCW_Direction); | |

/** | |

* Add an SkRRect contour to the path | |

* @param rrect The rounded rect to add as a closed contour | |

* @param dir The winding direction for the new contour. | |

* @param start Initial point of the contour (initial moveTo), expressed as | |

* an index of the radii minor/major points, ordered clock-wise: | |

* | |

* 0 1 | |

* *----* | |

* 7 * * 2 | |

* | | | |

* 6 * * 3 | |

* *----* | |

* 5 4 | |

*/ | |

void addRRect(const SkRRect& rrect, Direction dir, unsigned start); | |

/** | |

* Add a new contour made of just lines. This is just a fast version of | |

* the following: | |

* this->moveTo(pts[0]); | |

* for (int i = 1; i < count; ++i) { | |

* this->lineTo(pts[i]); | |

* } | |

* if (close) { | |

* this->close(); | |

* } | |

*/ | |

void addPoly(const SkPoint pts[], int count, bool close); | |

enum AddPathMode { | |

/** Source path contours are added as new contours. | |

*/ | |

kAppend_AddPathMode, | |

/** Path is added by extending the last contour of the destination path | |

with the first contour of the source path. If the last contour of | |

the destination path is closed, then it will not be extended. | |

Instead, the start of source path will be extended by a straight | |

line to the end point of the destination path. | |

*/ | |

kExtend_AddPathMode | |

}; | |

/** Add a copy of src to the path, offset by (dx,dy) | |

@param src The path to add as a new contour | |

@param dx The amount to translate the path in X as it is added | |

@param dx The amount to translate the path in Y as it is added | |

*/ | |

void addPath(const SkPath& src, SkScalar dx, SkScalar dy, | |

AddPathMode mode = kAppend_AddPathMode); | |

/** Add a copy of src to the path | |

*/ | |

void addPath(const SkPath& src, AddPathMode mode = kAppend_AddPathMode) { | |

SkMatrix m; | |

m.reset(); | |

this->addPath(src, m, mode); | |

} | |

/** Add a copy of src to the path, transformed by matrix | |

@param src The path to add as a new contour | |

@param matrix Transform applied to src | |

@param mode Determines how path is added | |

*/ | |

void addPath(const SkPath& src, const SkMatrix& matrix, AddPathMode mode = kAppend_AddPathMode); | |

/** | |

* Same as addPath(), but reverses the src input | |

*/ | |

void reverseAddPath(const SkPath& src); | |

/** Offset the path by (dx,dy), returning true on success | |

@param dx The amount in the X direction to offset the entire path | |

@param dy The amount in the Y direction to offset the entire path | |

@param dst The translated path is written here | |

*/ | |

void offset(SkScalar dx, SkScalar dy, SkPath* dst) const; | |

/** Offset the path by (dx,dy), returning true on success | |

@param dx The amount in the X direction to offset the entire path | |

@param dy The amount in the Y direction to offset the entire path | |

*/ | |

void offset(SkScalar dx, SkScalar dy) { | |

this->offset(dx, dy, this); | |

} | |

/** Transform the points in this path by matrix, and write the answer into | |

dst. | |

@param matrix The matrix to apply to the path | |

@param dst The transformed path is written here | |

*/ | |

void transform(const SkMatrix& matrix, SkPath* dst) const; | |

/** Transform the points in this path by matrix | |

@param matrix The matrix to apply to the path | |

*/ | |

void transform(const SkMatrix& matrix) { | |

this->transform(matrix, this); | |

} | |

/** Return the last point on the path. If no points have been added, (0,0) | |

is returned. If there are no points, this returns false, otherwise it | |

returns true. | |

@param lastPt The last point on the path is returned here | |

*/ | |

bool getLastPt(SkPoint* lastPt) const; | |

/** Set the last point on the path. If no points have been added, | |

moveTo(x,y) is automatically called. | |

@param x The new x-coordinate for the last point | |

@param y The new y-coordinate for the last point | |

*/ | |

void setLastPt(SkScalar x, SkScalar y); | |

/** Set the last point on the path. If no points have been added, moveTo(p) | |

is automatically called. | |

@param p The new location for the last point | |

*/ | |

void setLastPt(const SkPoint& p) { | |

this->setLastPt(p.fX, p.fY); | |

} | |

enum SegmentMask { | |

kLine_SegmentMask = 1 << 0, | |

kQuad_SegmentMask = 1 << 1, | |

kConic_SegmentMask = 1 << 2, | |

kCubic_SegmentMask = 1 << 3, | |

}; | |

/** | |

* Returns a mask, where each bit corresponding to a SegmentMask is | |

* set if the path contains 1 or more segments of that type. | |

* Returns 0 for an empty path (no segments). | |

*/ | |

uint32_t getSegmentMasks() const { return fPathRef->getSegmentMasks(); } | |

enum Verb { | |

kMove_Verb, //!< iter.next returns 1 point | |

kLine_Verb, //!< iter.next returns 2 points | |

kQuad_Verb, //!< iter.next returns 3 points | |

kConic_Verb, //!< iter.next returns 3 points + iter.conicWeight() | |

kCubic_Verb, //!< iter.next returns 4 points | |

kClose_Verb, //!< iter.next returns 0 points | |

kDone_Verb, //!< iter.next returns 0 points | |

}; | |

/** Iterate through all of the segments (lines, quadratics, cubics) of | |

each contours in a path. | |

The iterator cleans up the segments along the way, removing degenerate | |

segments and adding close verbs where necessary. When the forceClose | |

argument is provided, each contour (as defined by a new starting | |

move command) will be completed with a close verb regardless of the | |

contour's contents. | |

*/ | |

class SK_API Iter { | |

public: | |

Iter(); | |

Iter(const SkPath&, bool forceClose); | |

void setPath(const SkPath&, bool forceClose); | |

/** Return the next verb in this iteration of the path. When all | |

segments have been visited, return kDone_Verb. | |

@param pts The points representing the current verb and/or segment | |

@param doConsumeDegerates If true, first scan for segments that are | |

deemed degenerate (too short) and skip those. | |

@param exact if doConsumeDegenerates is true and exact is true, skip only | |

degenerate elements with lengths exactly equal to zero. If exact | |

is false, skip degenerate elements with lengths close to zero. If | |

doConsumeDegenerates is false, exact has no effect. | |

@return The verb for the current segment | |

*/ | |

Verb next(SkPoint pts[4], bool doConsumeDegerates = true, bool exact = false) { | |

if (doConsumeDegerates) { | |

this->consumeDegenerateSegments(exact); | |

} | |

return this->doNext(pts); | |

} | |

/** | |

* Return the weight for the current conic. Only valid if the current | |

* segment return by next() was a conic. | |

*/ | |

SkScalar conicWeight() const { return *fConicWeights; } | |

/** If next() returns kLine_Verb, then this query returns true if the | |

line was the result of a close() command (i.e. the end point is the | |

initial moveto for this contour). If next() returned a different | |

verb, this returns an undefined value. | |

@return If the last call to next() returned kLine_Verb, return true | |

if it was the result of an explicit close command. | |

*/ | |

bool isCloseLine() const { return SkToBool(fCloseLine); } | |

/** Returns true if the current contour is closed (has a kClose_Verb) | |

@return true if the current contour is closed (has a kClose_Verb) | |

*/ | |

bool isClosedContour() const; | |

private: | |

const SkPoint* fPts; | |

const uint8_t* fVerbs; | |

const uint8_t* fVerbStop; | |

const SkScalar* fConicWeights; | |

SkPoint fMoveTo; | |

SkPoint fLastPt; | |

SkBool8 fForceClose; | |

SkBool8 fNeedClose; | |

SkBool8 fCloseLine; | |

SkBool8 fSegmentState; | |

inline const SkPoint& cons_moveTo(); | |

Verb autoClose(SkPoint pts[2]); | |

void consumeDegenerateSegments(bool exact); | |

Verb doNext(SkPoint pts[4]); | |

}; | |

/** Iterate through the verbs in the path, providing the associated points. | |

*/ | |

class SK_API RawIter { | |

public: | |

RawIter() {} | |

RawIter(const SkPath& path) { | |

setPath(path); | |

} | |

void setPath(const SkPath& path) { | |

fRawIter.setPathRef(*path.fPathRef.get()); | |

} | |

/** Return the next verb in this iteration of the path. When all | |

segments have been visited, return kDone_Verb. | |

@param pts The points representing the current verb and/or segment | |

This must not be NULL. | |

@return The verb for the current segment | |

*/ | |

Verb next(SkPoint pts[4]) { | |

return (Verb) fRawIter.next(pts); | |

} | |

/** Return what the next verb will be, but do not visit the next segment. | |

@return The verb for the next segment | |

*/ | |

Verb peek() const { | |

return (Verb) fRawIter.peek(); | |

} | |

SkScalar conicWeight() const { | |

return fRawIter.conicWeight(); | |

} | |

private: | |

SkPathRef::Iter fRawIter; | |

friend class SkPath; | |

}; | |

/** | |

* Returns true if the point { x, y } is contained by the path, taking into | |

* account the FillType. | |

*/ | |

bool contains(SkScalar x, SkScalar y) const; | |

void dump(SkWStream* stream, bool forceClose, bool dumpAsHex) const; | |

void dump() const; | |

void dumpHex() const; | |

/** | |

* Write the path to the buffer, and return the number of bytes written. | |

* If buffer is NULL, it still returns the number of bytes. | |

*/ | |

size_t writeToMemory(void* buffer) const; | |

/** | |

* Initializes the path from the buffer | |

* | |

* @param buffer Memory to read from | |

* @param length Amount of memory available in the buffer | |

* @return number of bytes read (must be a multiple of 4) or | |

* 0 if there was not enough memory available | |

*/ | |

size_t readFromMemory(const void* buffer, size_t length); | |

/** Returns a non-zero, globally unique value corresponding to the set of verbs | |

and points in the path (but not the fill type [except on Android skbug.com/1762]). | |

Each time the path is modified, a different generation ID will be returned. | |

*/ | |

uint32_t getGenerationID() const; | |

#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK | |

static const int kPathRefGenIDBitCnt = 30; // leave room for the fill type (skbug.com/1762) | |

#else | |

static const int kPathRefGenIDBitCnt = 32; | |

#endif | |

SkDEBUGCODE(void validate() const;) | |

SkDEBUGCODE(void experimentalValidateRef() const { fPathRef->validate(); } ) | |

private: | |

enum SerializationOffsets { | |

// 1 free bit at 29 | |

kUnused1_SerializationShift = 28, // 1 free bit | |

kDirection_SerializationShift = 26, // requires 2 bits | |

kIsVolatile_SerializationShift = 25, // requires 1 bit | |

// 1 free bit at 24 | |

kConvexity_SerializationShift = 16, // requires 8 bits | |

kFillType_SerializationShift = 8, // requires 8 bits | |

// low-8-bits are version | |

}; | |

enum SerializationVersions { | |

kPathPrivFirstDirection_Version = 1, | |

kPathPrivLastMoveToIndex_Version = 2, | |

kCurrent_Version = 2 | |

}; | |

sk_sp<SkPathRef> fPathRef; | |

int fLastMoveToIndex; | |

uint8_t fFillType; | |

mutable uint8_t fConvexity; | |

mutable SkAtomic<uint8_t, sk_memory_order_relaxed> fFirstDirection;// SkPathPriv::FirstDirection | |

SkBool8 fIsVolatile; | |

/** Resets all fields other than fPathRef to their initial 'empty' values. | |

* Assumes the caller has already emptied fPathRef. | |

* On Android increments fGenerationID without reseting it. | |

*/ | |

void resetFields(); | |

/** Sets all fields other than fPathRef to the values in 'that'. | |

* Assumes the caller has already set fPathRef. | |

* Doesn't change fGenerationID or fSourcePath on Android. | |

*/ | |

void copyFields(const SkPath& that); | |

friend class Iter; | |

friend class SkPathPriv; | |

friend class SkPathStroker; | |

/* Append, in reverse order, the first contour of path, ignoring path's | |

last point. If no moveTo() call has been made for this contour, the | |

first point is automatically set to (0,0). | |

*/ | |

void reversePathTo(const SkPath&); | |

// called before we add points for lineTo, quadTo, cubicTo, checking to see | |

// if we need to inject a leading moveTo first | |

// | |

// SkPath path; path.lineTo(...); <--- need a leading moveTo(0, 0) | |

// SkPath path; ... path.close(); path.lineTo(...) <-- need a moveTo(previous moveTo) | |

// | |

inline void injectMoveToIfNeeded(); | |

inline bool hasOnlyMoveTos() const; | |

Convexity internalGetConvexity() const; | |

bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts, | |

bool* isClosed, Direction* direction) const; | |

// called by stroker to see if all points (in the last contour) are equal and worthy of a cap | |

bool isZeroLengthSincePoint(int startPtIndex) const; | |

/** Returns if the path can return a bound at no cost (true) or will have to | |

perform some computation (false). | |

*/ | |

bool hasComputedBounds() const { | |

SkDEBUGCODE(this->validate();) | |

return fPathRef->hasComputedBounds(); | |

} | |

// 'rect' needs to be sorted | |

void setBounds(const SkRect& rect) { | |

SkPathRef::Editor ed(&fPathRef); | |

ed.setBounds(rect); | |

} | |

void setPt(int index, SkScalar x, SkScalar y); | |

friend class SkAutoPathBoundsUpdate; | |

friend class SkAutoDisableOvalCheck; | |

friend class SkAutoDisableDirectionCheck; | |

friend class SkPathWriter; | |

friend class SkOpBuilder; | |

friend class SkBench_AddPathTest; // perf test reversePathTo | |

friend class PathTest_Private; // unit test reversePathTo | |

friend class ForceIsRRect_Private; // unit test isRRect | |

}; | |

#endif |