aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/SkEdgeBuilder.cpp51
-rw-r--r--src/core/SkEdgeBuilder.h1
-rw-r--r--src/core/SkPath.cpp162
-rw-r--r--src/core/SkPathMeasure.cpp3
-rw-r--r--src/core/SkPathRef.h88
-rw-r--r--src/core/SkRegion_path.cpp17
6 files changed, 89 insertions, 233 deletions
diff --git a/src/core/SkEdgeBuilder.cpp b/src/core/SkEdgeBuilder.cpp
index 9ac4e97443..608a83c7c7 100644
--- a/src/core/SkEdgeBuilder.cpp
+++ b/src/core/SkEdgeBuilder.cpp
@@ -153,22 +153,12 @@ int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip,
return edgePtr - fEdgeList;
}
-static void handle_quad(SkEdgeBuilder* builder, const SkPoint pts[3]) {
- SkPoint monoX[5];
- int n = SkChopQuadAtYExtrema(pts, monoX);
- for (int i = 0; i <= n; i++) {
- builder->addQuad(&monoX[i * 2]);
- }
-}
-
int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip,
int shiftUp) {
fAlloc.reset();
fList.reset();
fShiftUp = shiftUp;
- SkScalar conicTol = SK_ScalarHalf * (1 << shiftUp);
-
if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
return this->buildPoly(path, iclip, shiftUp);
}
@@ -202,24 +192,6 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip,
this->addClipper(&clipper);
}
break;
- case SkPath::kConic_Verb: {
- const int MAX_POW2 = 4;
- const int MAX_QUADS = 1 << MAX_POW2;
- const int MAX_QUAD_PTS = 1 + 2 * MAX_QUADS;
- SkPoint storage[MAX_QUAD_PTS];
-
- SkConic conic;
- conic.set(pts, iter.conicWeight());
- int pow2 = conic.computeQuadPOW2(conicTol);
- pow2 = SkMin32(pow2, MAX_POW2);
- int quadCount = conic.chopIntoQuadsPOW2(storage, pow2);
- SkASSERT(quadCount <= MAX_QUADS);
- for (int i = 0; i < quadCount; ++i) {
- if (clipper.clipQuad(&storage[i * 2], clip)) {
- this->addClipper(&clipper);
- }
- }
- } break;
case SkPath::kCubic_Verb:
if (clipper.clipCubic(pts, clip)) {
this->addClipper(&clipper);
@@ -242,26 +214,13 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip,
this->addLine(pts);
break;
case SkPath::kQuad_Verb: {
- handle_quad(this, pts);
+ SkPoint monoX[5];
+ int n = SkChopQuadAtYExtrema(pts, monoX);
+ for (int i = 0; i <= n; i++) {
+ this->addQuad(&monoX[i * 2]);
+ }
break;
}
- case SkPath::kConic_Verb: {
- const int MAX_POW2 = 4;
- const int MAX_QUADS = 1 << MAX_POW2;
- const int MAX_QUAD_PTS = 1 + 2 * MAX_QUADS;
- SkPoint storage[MAX_QUAD_PTS];
-
- SkConic conic;
- conic.set(pts, iter.conicWeight());
- int pow2 = conic.computeQuadPOW2(conicTol);
- pow2 = SkMin32(pow2, MAX_POW2);
- int quadCount = conic.chopIntoQuadsPOW2(storage, pow2);
- SkASSERT(quadCount <= MAX_QUADS);
- SkDebugf("--- quadCount = %d\n", quadCount);
- for (int i = 0; i < quadCount; ++i) {
- handle_quad(this, &storage[i * 2]);
- }
- } break;
case SkPath::kCubic_Verb: {
SkPoint monoY[10];
int n = SkChopCubicAtYExtrema(pts, monoY);
diff --git a/src/core/SkEdgeBuilder.h b/src/core/SkEdgeBuilder.h
index f9e5976e17..b296f773c1 100644
--- a/src/core/SkEdgeBuilder.h
+++ b/src/core/SkEdgeBuilder.h
@@ -40,7 +40,6 @@ private:
int fShiftUp;
-public:
void addLine(const SkPoint pts[]);
void addQuad(const SkPoint pts[]);
void addCubic(const SkPoint pts[]);
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 7485c0b4ff..95cd9fe938 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -369,7 +369,6 @@ bool SkPath::conservativelyContainsRect(const SkRect& rect) const {
SkASSERT(moveCnt);
break;
case kQuad_Verb:
- case kConic_Verb:
SkASSERT(moveCnt);
nextPt = 2;
break;
@@ -559,16 +558,12 @@ bool SkPath::isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts
break;
}
case kQuad_Verb:
- case kConic_Verb:
case kCubic_Verb:
return false; // quadratic, cubic not allowed
case kMove_Verb:
last = *pts++;
closedOrMoved = true;
break;
- default:
- SkASSERT(!"unexpected verb");
- break;
}
*currVerb += 1;
lastDirection = nextDirection;
@@ -810,15 +805,15 @@ void SkPath::rLineTo(SkScalar x, SkScalar y) {
void SkPath::quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
SkDEBUGCODE(this->validate();)
-
+
this->injectMoveToIfNeeded();
-
+
SkPathRef::Editor ed(&fPathRef);
SkPoint* pts = ed.growForVerb(kQuad_Verb);
pts[0].set(x1, y1);
pts[1].set(x2, y2);
fSegmentMask |= kQuad_SegmentMask;
-
+
GEN_ID_INC;
DIRTY_AFTER_EDIT;
}
@@ -829,39 +824,6 @@ void SkPath::rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
this->quadTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2);
}
-void SkPath::conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
- SkScalar w) {
- // check for <= 0 or NaN with this test
- if (!(w > 0)) {
- this->lineTo(x2, y2);
- } else if (!SkScalarIsFinite(w)) {
- this->lineTo(x1, y1);
- this->lineTo(x2, y2);
- } else if (SK_Scalar1 == w) {
- this->quadTo(x1, y1, x2, y2);
- } else {
- SkDEBUGCODE(this->validate();)
-
- this->injectMoveToIfNeeded();
-
- SkPathRef::Editor ed(&fPathRef);
- SkPoint* pts = ed.growForConic(w);
- pts[0].set(x1, y1);
- pts[1].set(x2, y2);
- fSegmentMask |= kConic_SegmentMask;
-
- GEN_ID_INC;
- DIRTY_AFTER_EDIT;
- }
-}
-
-void SkPath::rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
- SkScalar w) {
- SkPoint pt;
- this->getLastPt(&pt);
- this->conicTo(pt.fX + dx1, pt.fY + dy1, pt.fX + dx2, pt.fY + dy2, w);
-}
-
void SkPath::cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
SkScalar x3, SkScalar y3) {
SkDEBUGCODE(this->validate();)
@@ -895,7 +857,6 @@ void SkPath::close() {
switch (fPathRef->atVerb(count - 1)) {
case kLine_Verb:
case kQuad_Verb:
- case kConic_Verb:
case kCubic_Verb:
case kMove_Verb: {
SkPathRef::Editor ed(&fPathRef);
@@ -903,11 +864,8 @@ void SkPath::close() {
GEN_ID_INC;
break;
}
- case kClose_Verb:
- // don't add a close if it's the first verb or a repeat
- break;
default:
- SkASSERT(!"unexpected verb");
+ // don't add a close if it's the first verb or a repeat
break;
}
}
@@ -1472,10 +1430,6 @@ void SkPath::addPath(const SkPath& path, const SkMatrix& matrix) {
proc(matrix, &pts[1], &pts[1], 2);
this->quadTo(pts[1], pts[2]);
break;
- case kConic_Verb:
- proc(matrix, &pts[1], &pts[1], 2);
- this->conicTo(pts[1], pts[2], iter.conicWeight());
- break;
case kCubic_Verb:
proc(matrix, &pts[1], &pts[1], 3);
this->cubicTo(pts[1], pts[2], pts[3]);
@@ -1491,20 +1445,14 @@ void SkPath::addPath(const SkPath& path, const SkMatrix& matrix) {
///////////////////////////////////////////////////////////////////////////////
-static int pts_in_verb(unsigned verb) {
- static const uint8_t gPtsInVerb[] = {
- 1, // kMove
- 1, // kLine
- 2, // kQuad
- 2, // kConic
- 3, // kCubic
- 0, // kClose
- 0 // kDone
- };
-
- SkASSERT(verb < SK_ARRAY_COUNT(gPtsInVerb));
- return gPtsInVerb[verb];
-}
+static const uint8_t gPtsInVerb[] = {
+ 1, // kMove
+ 1, // kLine
+ 2, // kQuad
+ 3, // kCubic
+ 0, // kClose
+ 0 // kDone
+};
// ignore the initial moveto, and stop when the 1st contour ends
void SkPath::pathTo(const SkPath& path) {
@@ -1521,7 +1469,6 @@ void SkPath::pathTo(const SkPath& path) {
const uint8_t* verbs = path.fPathRef->verbs();
// skip the initial moveTo
const SkPoint* pts = path.fPathRef->points() + 1;
- const SkScalar* conicWeight = path.fPathRef->conicWeights();
SkASSERT(verbs[~0] == kMove_Verb);
for (i = 1; i < vcount; i++) {
@@ -1532,16 +1479,13 @@ void SkPath::pathTo(const SkPath& path) {
case kQuad_Verb:
this->quadTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
break;
- case kConic_Verb:
- this->conicTo(pts[0], pts[1], *conicWeight++);
- break;
case kCubic_Verb:
this->cubicTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
break;
case kClose_Verb:
return;
}
- pts += pts_in_verb(verbs[~i]);
+ pts += gPtsInVerb[verbs[~i]];
}
}
@@ -1559,17 +1503,14 @@ void SkPath::reversePathTo(const SkPath& path) {
const uint8_t* verbs = path.fPathRef->verbs();
const SkPoint* pts = path.fPathRef->points();
- const SkScalar* conicWeights = path.fPathRef->conicWeights();
SkASSERT(verbs[~0] == kMove_Verb);
for (i = 1; i < vcount; ++i) {
- unsigned v = verbs[~i];
- int n = pts_in_verb(v);
+ int n = gPtsInVerb[verbs[~i]];
if (n == 0) {
break;
}
pts += n;
- conicWeights += (SkPath::kConic_Verb == v);
}
while (--i > 0) {
@@ -1580,9 +1521,6 @@ void SkPath::reversePathTo(const SkPath& path) {
case kQuad_Verb:
this->quadTo(pts[-1].fX, pts[-1].fY, pts[-2].fX, pts[-2].fY);
break;
- case kConic_Verb:
- this->conicTo(pts[-1], pts[-2], *--conicWeights);
- break;
case kCubic_Verb:
this->cubicTo(pts[-1].fX, pts[-1].fY, pts[-2].fX, pts[-2].fY,
pts[-3].fX, pts[-3].fY);
@@ -1591,7 +1529,7 @@ void SkPath::reversePathTo(const SkPath& path) {
SkDEBUGFAIL("bad verb");
break;
}
- pts -= pts_in_verb(verbs[~i]);
+ pts -= gPtsInVerb[verbs[~i]];
}
}
@@ -1602,7 +1540,6 @@ void SkPath::reverseAddPath(const SkPath& src) {
// we will iterator through src's verbs backwards
const uint8_t* verbs = src.fPathRef->verbsMemBegin(); // points at the last verb
const uint8_t* verbsEnd = src.fPathRef->verbs(); // points just past the first verb
- const SkScalar* conicWeights = src.fPathRef->conicWeightsEnd();
fIsOval = false;
@@ -1610,7 +1547,7 @@ void SkPath::reverseAddPath(const SkPath& src) {
bool needClose = false;
while (verbs < verbsEnd) {
uint8_t v = *(verbs++);
- int n = pts_in_verb(v);
+ int n = gPtsInVerb[v];
if (needMove) {
--pts;
@@ -1633,9 +1570,6 @@ void SkPath::reverseAddPath(const SkPath& src) {
case kQuad_Verb:
this->quadTo(pts[1], pts[0]);
break;
- case kConic_Verb:
- this->conicTo(pts[1], pts[0], *--conicWeights);
- break;
case kCubic_Verb:
this->cubicTo(pts[2], pts[1], pts[0]);
break;
@@ -1710,10 +1644,6 @@ void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const {
case kQuad_Verb:
subdivide_quad_to(&tmp, pts);
break;
- case kConic_Verb:
- SkASSERT(!"TODO: compute new weight");
- tmp.conicTo(pts[1], pts[2], iter.conicWeight());
- break;
case kCubic_Verb:
subdivide_cubic_to(&tmp, pts);
break;
@@ -1811,7 +1741,6 @@ enum SegmentState {
SkPath::Iter::Iter() {
#ifdef SK_DEBUG
fPts = NULL;
- fConicWeights = NULL;
fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
fForceClose = fCloseLine = false;
fSegmentState = kEmptyContour_SegmentState;
@@ -1830,7 +1759,6 @@ void SkPath::Iter::setPath(const SkPath& path, bool forceClose) {
fPts = path.fPathRef->points();
fVerbs = path.fPathRef->verbs();
fVerbStop = path.fPathRef->verbsMemBegin();
- fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
fLastPt.fX = fLastPt.fY = 0;
fMoveTo.fX = fMoveTo.fY = 0;
fForceClose = SkToU8(forceClose);
@@ -1942,7 +1870,6 @@ void SkPath::Iter::consumeDegenerateSegments() {
fPts++;
break;
- case kConic_Verb:
case kQuad_Verb:
if (!IsQuadDegenerate(lastPt, fPts[0], fPts[1])) {
if (lastMoveVerb) {
@@ -1955,7 +1882,6 @@ void SkPath::Iter::consumeDegenerateSegments() {
// Ignore this line and continue
fVerbs--;
fPts += 2;
- fConicWeights += (kConic_Verb == verb);
break;
case kCubic_Verb:
@@ -2025,9 +1951,6 @@ SkPath::Verb SkPath::Iter::doNext(SkPoint ptsParam[4]) {
fCloseLine = false;
srcPts += 1;
break;
- case kConic_Verb:
- fConicWeights += 1;
- // fall-through
case kQuad_Verb:
pts[0] = this->cons_moveTo();
memcpy(&pts[1], srcPts, 2 * sizeof(SkPoint));
@@ -2060,7 +1983,6 @@ SkPath::Verb SkPath::Iter::doNext(SkPoint ptsParam[4]) {
SkPath::RawIter::RawIter() {
#ifdef SK_DEBUG
fPts = NULL;
- fConicWeights = NULL;
fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
#endif
// need to init enough to make next() harmlessly return kDone_Verb
@@ -2076,7 +1998,6 @@ void SkPath::RawIter::setPath(const SkPath& path) {
fPts = path.fPathRef->points();
fVerbs = path.fPathRef->verbs();
fVerbStop = path.fPathRef->verbsMemBegin();
- fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
fMoveTo.fX = fMoveTo.fY = 0;
fLastPt.fX = fLastPt.fY = 0;
}
@@ -2104,9 +2025,6 @@ SkPath::Verb SkPath::RawIter::next(SkPoint pts[4]) {
fLastPt = srcPts[0];
srcPts += 1;
break;
- case kConic_Verb:
- fConicWeights += 1;
- // fall-through
case kQuad_Verb:
pts[0] = fLastPt;
memcpy(&pts[1], srcPts, 2 * sizeof(SkPoint));
@@ -2139,12 +2057,22 @@ uint32_t SkPath::writeToMemory(void* storage) const {
if (NULL == storage) {
const int byteCount = sizeof(int32_t)
+#if NEW_PICTURE_FORMAT
+ fPathRef->writeSize()
+#else
+ + 2 * sizeof(int32_t)
+ + sizeof(SkPoint) * fPathRef->countPoints()
+ + sizeof(uint8_t) * fPathRef->countVerbs()
+#endif
+ sizeof(SkRect);
return SkAlign4(byteCount);
}
SkWBuffer buffer(storage);
+#if !NEW_PICTURE_FORMAT
+ buffer.write32(fPathRef->countPoints());
+ buffer.write32(fPathRef->countVerbs());
+#endif
// Call getBounds() to ensure (as a side-effect) that fBounds
// and fIsFinite are computed.
@@ -2170,16 +2098,24 @@ uint32_t SkPath::writeToMemory(void* storage) const {
uint32_t SkPath::readFromMemory(const void* storage) {
SkRBuffer buffer(storage);
+#if !NEW_PICTURE_FORMAT
+ int32_t pcount = buffer.readS32();
+ int32_t vcount = buffer.readS32();
+#endif
uint32_t packed = buffer.readS32();
fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
fIsOval = (packed >> kIsOval_SerializationShift) & 1;
fConvexity = (packed >> kConvexity_SerializationShift) & 0xFF;
fFillType = (packed >> kFillType_SerializationShift) & 0xFF;
- fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
+ fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0x7;
fDirection = (packed >> kDirection_SerializationShift) & 0x3;
+#if NEW_PICTURE_FORMAT
fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer));
+#else
+ fPathRef.reset(SkPathRef::CreateFromBuffer(vcount, pcount, &buffer));
+#endif
buffer.read(&fBounds, sizeof(fBounds));
fBoundsIsDirty = false;
@@ -2206,7 +2142,7 @@ static void append_scalar(SkString* str, SkScalar value) {
}
static void append_params(SkString* str, const char label[], const SkPoint pts[],
- int count, SkScalar conicWeight = -1) {
+ int count) {
str->append(label);
str->append("(");
@@ -2219,10 +2155,6 @@ static void append_params(SkString* str, const char label[], const SkPoint pts[]
str->append(", ");
}
}
- if (conicWeight >= 0) {
- str->append(", ");
- append_scalar(str, conicWeight);
- }
str->append(");\n");
}
@@ -2248,9 +2180,6 @@ void SkPath::dump(bool forceClose, const char title[]) const {
case kQuad_Verb:
append_params(&builder, "path.quadTo", &pts[1], 2);
break;
- case kConic_Verb:
- append_params(&builder, "path.conicTo", &pts[1], 2, iter.conicWeight());
- break;
case kCubic_Verb:
append_params(&builder, "path.cubicTo", &pts[1], 3);
break;
@@ -2310,9 +2239,6 @@ void SkPath::validate() const {
case kQuad_Verb:
mask |= kQuad_SegmentMask;
break;
- case kConic_Verb:
- mask |= kConic_SegmentMask;
- break;
case kCubic_Verb:
mask |= kCubic_SegmentMask;
case kMove_Verb: // these verbs aren't included in the segment mask.
@@ -2453,7 +2379,6 @@ SkPath::Convexity SkPath::internalGetConvexity() const {
break;
case kLine_Verb: count = 1; break;
case kQuad_Verb: count = 2; break;
- case kConic_Verb: count = 2; break;
case kCubic_Verb: count = 3; break;
case kClose_Verb:
state.close();
@@ -2498,7 +2423,6 @@ private:
const SkPoint* fCurrPt;
const uint8_t* fCurrVerb;
const uint8_t* fStopVerbs;
- const SkScalar* fCurrConicWeight;
bool fDone;
SkDEBUGCODE(int fContourCounter;)
};
@@ -2508,7 +2432,6 @@ ContourIter::ContourIter(const SkPathRef& pathRef) {
fDone = false;
fCurrPt = pathRef.points();
fCurrVerb = pathRef.verbs();
- fCurrConicWeight = pathRef.conicWeights();
fCurrPtCount = 0;
SkDEBUGCODE(fContourCounter = 0;)
this->next();
@@ -2536,19 +2459,13 @@ void ContourIter::next() {
case SkPath::kLine_Verb:
ptCount += 1;
break;
- case SkPath::kConic_Verb:
- fCurrConicWeight += 1;
- // fall-through
case SkPath::kQuad_Verb:
ptCount += 2;
break;
case SkPath::kCubic_Verb:
ptCount += 3;
break;
- case SkPath::kClose_Verb:
- break;
- default:
- SkASSERT(!"unexpected verb");
+ default: // kClose_Verb, just keep going
break;
}
}
@@ -3040,16 +2957,13 @@ bool SkPath::contains(SkScalar x, SkScalar y) const {
case SkPath::kQuad_Verb:
w += winding_quad(pts, x, y);
break;
- case SkPath::kConic_Verb:
- SkASSERT(0);
- break;
case SkPath::kCubic_Verb:
w += winding_cubic(pts, x, y);
break;
case SkPath::kDone_Verb:
done = true;
break;
- }
+ }
} while (!done);
switch (this->getFillType()) {
diff --git a/src/core/SkPathMeasure.cpp b/src/core/SkPathMeasure.cpp
index c519f93dce..af2579fff1 100644
--- a/src/core/SkPathMeasure.cpp
+++ b/src/core/SkPathMeasure.cpp
@@ -152,9 +152,6 @@ void SkPathMeasure::buildSegments() {
bool done = false;
do {
switch (fIter.next(pts)) {
- case SkPath::kConic_Verb:
- SkASSERT(0);
- break;
case SkPath::kMove_Verb:
ptIndex += 1;
fPts.append(1, pts);
diff --git a/src/core/SkPathRef.h b/src/core/SkPathRef.h
index b670039291..5f85b7b896 100644
--- a/src/core/SkPathRef.h
+++ b/src/core/SkPathRef.h
@@ -12,6 +12,12 @@
#include "SkRefCnt.h"
#include <stddef.h> // ptrdiff_t
+// When we're ready to break the picture format. Changes:
+// * Write genID.
+// * SkPathRef read/write counts (which will change the field order)
+// * SkPathRef reads/writes verbs backwards.
+#define NEW_PICTURE_FORMAT 0
+
/**
* Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
* modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
@@ -103,13 +109,6 @@ public:
return fPathRef->growForVerb(verb);
}
- SkPoint* growForConic(SkScalar w) {
- fPathRef->validate();
- SkPoint* pts = fPathRef->growForVerb(SkPath::kConic_Verb);
- *fPathRef->fConicWeights.append() = w;
- return pts;
- }
-
/**
* Allocates space for additional verbs and points and returns pointers to the new verbs and
* points. verbs will point one beyond the first new verb (index it using [~<i>]). pts points
@@ -132,8 +131,8 @@ public:
* Resets the path ref to a new verb and point count. The new verbs and points are
* uninitialized.
*/
- void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
- fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
+ void resetToSize(int newVerbCnt, int newPointCnt) {
+ fPathRef->resetToSize(newVerbCnt, newPointCnt);
}
/**
* Gets the path ref that is wrapped in the Editor.
@@ -203,29 +202,40 @@ public:
} else if (rcnt > 1) {
dst->reset(SkNEW(SkPathRef));
}
- (*dst)->resetToSize(src.fVerbCnt, src.fPointCnt, src.fConicWeights.count());
+ (*dst)->resetToSize(src.fVerbCnt, src.fPointCnt);
memcpy((*dst)->verbsMemWritable(), src.verbsMemBegin(), src.fVerbCnt * sizeof(uint8_t));
matrix.mapPoints((*dst)->fPoints, src.points(), src.fPointCnt);
- (*dst)->fConicWeights = src.fConicWeights;
(*dst)->validate();
}
+#if NEW_PICTURE_FORMAT
static SkPathRef* CreateFromBuffer(SkRBuffer* buffer) {
SkPathRef* ref = SkNEW(SkPathRef);
ref->fGenerationID = buffer->readU32();
int32_t verbCount = buffer->readS32();
int32_t pointCount = buffer->readS32();
- int32_t conicCount = buffer->readS32();
- ref->resetToSize(verbCount, pointCount, conicCount);
+ ref->resetToSize(verbCount, pointCount);
SkASSERT(verbCount == ref->countVerbs());
SkASSERT(pointCount == ref->countPoints());
- SkASSERT(conicCount == ref->fConicWeights.count());
buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t));
buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
- buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar));
return ref;
}
+#else
+ static SkPathRef* CreateFromBuffer(int verbCount, int pointCount, SkRBuffer* buffer) {
+ SkPathRef* ref = SkNEW(SkPathRef);
+
+ ref->resetToSize(verbCount, pointCount);
+ SkASSERT(verbCount == ref->countVerbs());
+ SkASSERT(pointCount == ref->countPoints());
+ buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
+ for (int i = 0; i < verbCount; ++i) {
+ ref->fVerbs[~i] = buffer->readU8();
+ }
+ return ref;
+ }
+#endif
/**
* Rollsback a path ref to zero verbs and points with the assumption that the path ref will be
@@ -239,13 +249,12 @@ public:
(*pathRef)->fPointCnt = 0;
(*pathRef)->fFreeSpace = (*pathRef)->currSize();
(*pathRef)->fGenerationID = 0;
- (*pathRef)->fConicWeights.rewind();
(*pathRef)->validate();
} else {
int oldVCnt = (*pathRef)->countVerbs();
int oldPCnt = (*pathRef)->countPoints();
pathRef->reset(SkNEW(SkPathRef));
- (*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
+ (*pathRef)->resetToSize(0, 0, oldVCnt, oldPCnt);
}
}
@@ -290,9 +299,6 @@ public:
*/
const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); }
- const SkScalar* conicWeights() const { this->validate(); return fConicWeights.begin(); }
- const SkScalar* conicWeightsEnd() const { this->validate(); return fConicWeights.end(); }
-
/**
* Convenience methods for getting to a verb or point by index.
*/
@@ -331,10 +337,6 @@ public:
SkASSERT(!genIDMatch);
return false;
}
- if (fConicWeights != ref.fConicWeights) {
- SkASSERT(!genIDMatch);
- return false;
- }
// We've done the work to determine that these are equal. If either has a zero genID, copy
// the other's. If both are 0 then genID() will compute the next ID.
if (0 == fGenerationID) {
@@ -348,6 +350,7 @@ public:
/**
* Writes the path points and verbs to a buffer.
*/
+#if NEW_PICTURE_FORMAT
void writeToBuffer(SkWBuffer* buffer) {
this->validate();
SkDEBUGCODE_X(size_t beforePos = buffer->pos();)
@@ -355,12 +358,10 @@ public:
// TODO: write gen ID here. Problem: We don't know if we're cross process or not from
// SkWBuffer. Until this is fixed we write 0.
buffer->write32(0);
- buffer->write32(fVerbCnt);
- buffer->write32(fPointCnt);
- buffer->write32(fConicWeights.count());
- buffer->write(verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
+ buffer->write32(this->fVerbCnt);
+ buffer->write32(this->fPointCnt);
+ buffer->write(this->verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
- buffer->write(fConicWeights.begin(), fConicWeights.bytes());
SkASSERT(buffer->pos() - beforePos == (size_t) this->writeSize());
}
@@ -369,11 +370,17 @@ public:
* Gets the number of bytes that would be written in writeBuffer()
*/
uint32_t writeSize() {
- return 4 * sizeof(uint32_t) +
- fVerbCnt * sizeof(uint8_t) +
- fPointCnt * sizeof(SkPoint) +
- fConicWeights.bytes();
+ return 3 * sizeof(uint32_t) + fVerbCnt * sizeof(uint8_t) + fPointCnt * sizeof(SkPoint);
}
+#else
+ void writeToBuffer(SkWBuffer* buffer) {
+ this->validate();
+ buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
+ for (int i = 0; i < fVerbCnt; ++i) {
+ buffer->write8(fVerbs[~i]);
+ }
+ }
+#endif
private:
SkPathRef() {
@@ -389,11 +396,10 @@ private:
void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints) {
this->validate();
- this->resetToSize(ref.fVerbCnt, ref.fPointCnt, ref.fConicWeights.count(),
+ this->resetToSize(ref.fVerbCnt, ref.fPointCnt,
additionalReserveVerbs, additionalReservePoints);
memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt * sizeof(uint8_t));
memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
- fConicWeights = ref.fConicWeights;
// We could call genID() here to force a real ID (instead of 0). However, if we're making
// a copy then presumably we intend to make a modification immediately afterwards.
fGenerationID = ref.fGenerationID;
@@ -410,8 +416,7 @@ private:
/** Resets the path ref with verbCount verbs and pointCount points, all unitialized. Also
* allocates space for reserveVerb additional verbs and reservePoints additional points.*/
- void resetToSize(int verbCount, int pointCount, int conicCount,
- int reserveVerbs = 0, int reservePoints = 0) {
+ void resetToSize(int verbCount, int pointCount, int reserveVerbs = 0, int reservePoints = 0) {
this->validate();
fGenerationID = 0;
@@ -437,7 +442,6 @@ private:
fVerbCnt = verbCount;
fFreeSpace = this->currSize() - minSize;
}
- fConicWeights.setCount(conicCount);
this->validate();
}
@@ -470,17 +474,13 @@ private:
case SkPath::kLine_Verb:
pCnt = 1;
break;
- case SkPath::kConic_Verb:
case SkPath::kQuad_Verb:
pCnt = 2;
break;
case SkPath::kCubic_Verb:
pCnt = 3;
break;
- case SkPath::kDone_Verb:
- SkASSERT(!"growForVerb called for kDone");
- // fall through
- case SkPath::kClose_Verb:
+ default:
pCnt = 0;
}
size_t space = sizeof(uint8_t) + pCnt * sizeof (SkPoint);
@@ -588,8 +588,6 @@ private:
int fVerbCnt;
int fPointCnt;
size_t fFreeSpace; // redundant but saves computation
- SkTDArray<SkScalar> fConicWeights;
-
enum {
kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
};
diff --git a/src/core/SkRegion_path.cpp b/src/core/SkRegion_path.cpp
index 0a5a401809..80149a3836 100644
--- a/src/core/SkRegion_path.cpp
+++ b/src/core/SkRegion_path.cpp
@@ -216,36 +216,25 @@ void SkRgnBuilder::copyToRgn(SkRegion::RunType runs[]) const {
*runs = SkRegion::kRunTypeSentinel;
}
-static unsigned verb_to_initial_last_index(unsigned verb) {
+static int count_path_runtype_values(const SkPath& path, int* itop, int* ibot) {
static const uint8_t gPathVerbToInitialLastIndex[] = {
0, // kMove_Verb
1, // kLine_Verb
2, // kQuad_Verb
- 2, // kConic_Verb
3, // kCubic_Verb
0, // kClose_Verb
0 // kDone_Verb
};
- SkASSERT((unsigned)verb < SK_ARRAY_COUNT(gPathVerbToInitialLastIndex));
- return gPathVerbToInitialLastIndex[verb];
-}
-static unsigned verb_to_max_edges(unsigned verb) {
static const uint8_t gPathVerbToMaxEdges[] = {
0, // kMove_Verb
1, // kLine_Verb
2, // kQuad_VerbB
- 2, // kConic_VerbB
3, // kCubic_Verb
0, // kClose_Verb
0 // kDone_Verb
};
- SkASSERT((unsigned)verb < SK_ARRAY_COUNT(gPathVerbToMaxEdges));
- return gPathVerbToMaxEdges[verb];
-}
-
-static int count_path_runtype_values(const SkPath& path, int* itop, int* ibot) {
SkPath::Iter iter(path, true);
SkPoint pts[4];
SkPath::Verb verb;
@@ -255,9 +244,9 @@ static int count_path_runtype_values(const SkPath& path, int* itop, int* ibot) {
SkScalar bot = SkIntToScalar(SK_MinS16);
while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
- maxEdges += verb_to_max_edges(verb);
+ maxEdges += gPathVerbToMaxEdges[verb];
- int lastIndex = verb_to_initial_last_index(verb);
+ int lastIndex = gPathVerbToInitialLastIndex[verb];
if (lastIndex > 0) {
for (int i = 1; i <= lastIndex; i++) {
if (top > pts[i].fY) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-07 05:10:36 +0000