Share code with SkRect
http://codereview.appspot.com/4523046/
git-svn-id: http://skia.googlecode.com/svn/trunk@1277 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/include/GrMatrix.h b/gpu/include/GrMatrix.h
index 1ebc0b4..19a6644 100644
--- a/gpu/include/GrMatrix.h
+++ b/gpu/include/GrMatrix.h
@@ -18,9 +18,7 @@
#ifndef GrMatrix_DEFINED
#define GrMatrix_DEFINED
-#include "GrPoint.h"
-
-struct GrRect;
+#include "GrRect.h"
/*
* 3x3 matrix
diff --git a/gpu/include/GrPathIter.h b/gpu/include/GrPathIter.h
index 2c84145..e67ff69 100644
--- a/gpu/include/GrPathIter.h
+++ b/gpu/include/GrPathIter.h
@@ -18,9 +18,7 @@
#ifndef GrPathIter_DEFINED
#define GrPathIter_DEFINED
-#include "GrPoint.h"
-
-struct GrRect;
+#include "GrRect.h"
/**
2D Path iterator. Porting layer creates a subclass of this. It allows Ganesh to
diff --git a/gpu/include/GrRect.h b/gpu/include/GrRect.h
index 7d03396..81f1545 100644
--- a/gpu/include/GrRect.h
+++ b/gpu/include/GrRect.h
@@ -19,465 +19,24 @@
#define GrRect_DEFINED
#include "GrPoint.h"
+#include "SkRect.h"
-struct GrIRect {
- int32_t fLeft, fTop, fRight, fBottom;
-
- GrIRect() {}
- GrIRect(int32_t left, int32_t top, int32_t right, int32_t bottom) {
- fLeft = left;
- fTop = top;
- fRight = right;
- fBottom = bottom;
- }
-
- int32_t x() const { return fLeft; }
- int32_t y() const { return fTop; }
- int32_t width() const { return fRight - fLeft; }
- int32_t height() const { return fBottom - fTop; }
-
- bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
- bool isInverted() const { return fLeft > fRight || fTop > fBottom; }
-
- void setEmpty() { fLeft = fTop = fRight = fBottom = 0; }
-
- void setXYWH(int32_t x, int32_t y, int32_t w, int32_t h) {
- fLeft = x;
- fTop = y;
- fRight = x + w;
- fBottom = y + h;
- }
-
- void setLTRB(int32_t l, int32_t t, int32_t r, int32_t b) {
- fLeft = l;
- fTop = t;
- fRight = r;
- fBottom = b;
- }
-
- /**
- * Make the largest representable rectangle
- */
- void setLargest() {
- fLeft = fTop = GR_Int32Min;
- fRight = fBottom = GR_Int32Max;
- }
-
- void setLargestInverted() {
- fLeft = fTop = GR_Int32Max;
- fRight = fBottom = GR_Int32Min;
- }
-
- bool quickReject(int l, int t, int r, int b) const {
- return l >= fRight || fLeft >= r || t >= fBottom || fTop >= b;
- }
-
- void unionWith(const GrIRect& r) {
- if (fLeft > r.fLeft) fLeft = r.fLeft;
- if (fTop > r.fTop) fTop = r.fTop;
- if (fRight < r.fRight) fRight = r.fRight;
- if (fBottom < r.fBottom) fBottom = r.fBottom;
- }
-
- /**
- * Sets this rect to the intersection with a clip rect. If there is no
- * intersection then this rect will be made empty and the function will
- * return false.
- */
- bool intersectWith(const GrIRect& clipRect) {
- if (fRight < clipRect.fLeft ||
- fLeft > clipRect.fRight ||
- fBottom < clipRect.fTop ||
- fTop > clipRect.fBottom) {
- this->setEmpty();
- return false;
- } else {
- fLeft = GrMax(fLeft, clipRect.fLeft);
- fRight = GrMin(fRight, clipRect.fRight);
- fTop = GrMax(fTop, clipRect.fTop);
- fBottom = GrMin(fBottom, clipRect.fBottom);
- return true;
- }
- }
-
- bool intersectWith(int left, int top,
- int right, int bottom) {
- if (fRight < left ||
- fLeft > right ||
- fBottom < top ||
- fTop > bottom) {
- this->setEmpty();
- return false;
- } else {
- fLeft = GrMax(fLeft, left);
- fRight = GrMin(fRight, right);
- fTop = GrMax(fTop, top);
- fBottom = GrMin(fBottom, bottom);
- return true;
- }
- }
-
- /**
- * Enlarge the rectangle to include rect.
- */
- void growToInclude(const GrIRect& rect) {
- GrAssert(!rect.isEmpty());
- fLeft = GrMin(rect.fLeft, fLeft);
- fRight = GrMax(rect.fRight, fRight);
-
- fTop = GrMin(rect.fTop, fTop);
- fBottom = GrMax(rect.fBottom, fBottom);
- }
-
- friend bool operator==(const GrIRect& a, const GrIRect& b) {
- return 0 == memcmp(&a, &b, sizeof(a));
- }
-
- friend bool operator!=(const GrIRect& a, const GrIRect& b) {
- return 0 != memcmp(&a, &b, sizeof(a));
- }
-
- bool equalsLTRB(int l, int t, int r, int b) const {
- return fLeft == l && fTop == t &&
- fRight == r && fBottom == b;
- }
- bool equalsXYWH(int x, int y, int w, int h) const {
- return fLeft == x && fTop == y &&
- this->width() == w && this->height() == h;
- }
-
- bool contains(const GrIRect& r) const {
- return fLeft <= r.fLeft &&
- fRight >= r.fRight &&
- fTop <= r.fTop &&
- fBottom >= r.fBottom;
- }
-
- static const GrIRect& EmptyIRect() {
- static const GrIRect gEmpty(0,0,0,0);
- return gEmpty;
- }
-};
+typedef SkIRect GrIRect;
+typedef SkRect GrRect;
struct GrIRect16 {
int16_t fLeft, fTop, fRight, fBottom;
-
+
int width() const { return fRight - fLeft; }
int height() const { return fBottom - fTop; }
int area() const { return this->width() * this->height(); }
bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
-
+
void set(const GrIRect& r) {
- fLeft = GrToS16(r.fLeft);
- fTop = GrToS16(r.fTop);
- fRight = GrToS16(r.fRight);
- fBottom = GrToS16(r.fBottom);
- }
-};
-
-/**
- * 2D Rect struct
- */
-struct GrRect {
- GrScalar fLeft, fTop, fRight, fBottom;
-
- /**
- * Uninitialized rectangle.
- */
- GrRect() {}
-
- /**
- * Initialize a rectangle to a point.
- * @param pt the point used to initialize the rectanglee.
- */
- explicit GrRect(const GrPoint& pt) {
- setToPoint(pt);
- }
-
- GrRect(GrScalar left, GrScalar top, GrScalar right, GrScalar bottom) {
- fLeft = left;
- fTop = top;
- fRight = right;
- fBottom = bottom;
- }
-
- explicit GrRect(const GrIRect& src) {
- fLeft = GrIntToScalar(src.fLeft);
- fTop = GrIntToScalar(src.fTop);
- fRight = GrIntToScalar(src.fRight);
- fBottom = GrIntToScalar(src.fBottom);
- }
-
- GrScalar x() const { return fLeft; }
- GrScalar y() const { return fTop; }
- GrScalar width() const { return fRight - fLeft; }
- GrScalar height() const { return fBottom - fTop; }
-
- GrScalar left() const { return fLeft; }
- GrScalar top() const { return fTop; }
- GrScalar right() const { return fRight; }
- GrScalar bottom() const { return fBottom; }
-
- GrScalar diagonalLengthSqd() const {
- GrScalar w = width();
- GrScalar h = height();
- return GrMul(w, w) + GrMul(h, h);
- }
-
- GrScalar diagonalLength() const {
- // TODO: fixed point sqrt
- return GrFloatToScalar(sqrtf(GrScalarToFloat(diagonalLengthSqd())));
- }
-
- /**
- * Returns true if the width or height is <= 0
- */
- bool isEmpty() const {
- return fLeft >= fRight || fTop >= fBottom;
- }
-
- void setEmpty() {
- fLeft = fTop = fRight = fBottom = 0;
- }
-
- /**
- * returns true if the rectangle is inverted either in x or y
- */
- bool isInverted() const {
- return (fLeft > fRight) || (fTop > fBottom);
- }
-
- /**
- * Returns true if the rects edges are integer-aligned.
- */
- bool isIRect() const {
- return GrScalarIsInt(fLeft) && GrScalarIsInt(fTop) &&
- GrScalarIsInt(fRight) && GrScalarIsInt(fBottom);
- }
-
- /**
- * Does this rect contain a point.
- */
- bool contains(const GrPoint& point) const {
- return point.fX >= fLeft && point.fX < fRight &&
- point.fY >= fTop && point.fY < fBottom;
- }
-
- /**
- * Returns true if the rect contains the point or the
- * point lies on the edge of the rect.
- */
- bool containsInclusive(const GrPoint& point) const {
- return point.fX >= fLeft && point.fX <= fRight &&
- point.fY >= fTop && point.fY <= fBottom;
- }
-
- /**
- * Does this rect fully contain another rect.
- */
- bool contains(const GrRect& r) const {
- return fLeft <= r.fLeft &&
- fRight >= r.fRight &&
- fTop <= r.fTop &&
- fBottom >= r.fBottom;
- }
-
- /**
- * Offset the rectangle by (tx, ty), adding tx to the horizontal position
- * and adds ty to the vertical position.
- */
- void offset(GrScalar tx, GrScalar ty) {
- fLeft += tx; fTop += ty;
- fRight += tx; fBottom += ty;
- }
-
- /**
- * Inset the rectangle by dx,dy. If dx > 0 the rect becomes narrower,
- * if dx < 0 the rect becomes wider.
- */
- void inset(GrScalar dx, GrScalar dy) {
- fLeft += dx; fTop += dy;
- fRight -= dx; fBottom -= dy;
- }
-
- /**
- * Initialize a rectangle to a point.
- * @param pt the point used to initialize the rectangle.
- */
- void setToPoint(const GrPoint& pt) {
- fLeft = pt.fX;
- fTop = pt.fY;
- fRight = pt.fX;
- fBottom = pt.fY;
- }
-
- void set(const GrIRect& r) {
- fLeft = GrIntToScalar(r.fLeft);
- fTop = GrIntToScalar(r.fTop);
- fRight = GrIntToScalar(r.fRight);
- fBottom = GrIntToScalar(r.fBottom);
- }
-
- void roundOut(GrIRect* r) const {
- r->setLTRB(GrScalarFloorToInt(fLeft),
- GrScalarFloorToInt(fTop),
- GrScalarCeilToInt(fRight),
- GrScalarCeilToInt(fBottom));
- }
-
- /**
- * Set the rect to the union of the array of points. If the array is empty
- * the rect will be empty [0,0,0,0]
- */
- void setBounds(const GrPoint pts[], int count);
-
- /**
- * Make the largest representable rectangle
- * Set the rect to fLeft = fTop = GR_ScalarMin and
- * fRight = fBottom = GR_ScalarMax.
- */
- void setLargest() {
- fLeft = fTop = GR_ScalarMin;
- fRight = fBottom = GR_ScalarMax;
- }
-
- /**
- Set the rect to fLeft = fTop = GR_ScalarMax and
- fRight = fBottom = GR_ScalarMin.
- Useful for initializing a bounding rectangle.
- */
- void setLargestInverted() {
- fLeft = fTop = GR_ScalarMax;
- fRight = fBottom = GR_ScalarMin;
- }
-
- void setLTRB(GrScalar left,
- GrScalar top,
- GrScalar right,
- GrScalar bottom) {
- fLeft = left;
- fTop = top;
- fRight = right;
- fBottom = bottom;
- }
-
- void setXYWH(GrScalar x, GrScalar y, GrScalar width, GrScalar height) {
- fLeft = x;
- fTop = y;
- fRight = x + width;
- fBottom = y + height;
- }
-
- /**
- Expand the edges of the rectangle to include a point.
- Useful for constructing a bounding rectangle.
- @param pt the point used to grow the rectangle.
- */
- void growToInclude(const GrPoint& pt) {
- fLeft = GrMin(pt.fX, fLeft);
- fRight = GrMax(pt.fX, fRight);
-
- fTop = GrMin(pt.fY, fTop);
- fBottom = GrMax(pt.fY, fBottom);
- }
-
- void growToInclude(GrScalar x, GrScalar y) {
- fLeft = GrMin(x, fLeft);
- fRight = GrMax(y, fRight);
-
- fTop = GrMin(x, fTop);
- fBottom = GrMax(y, fBottom);
- }
-
- /**
- * Grows a rect to include another rect.
- * @param rect the rect to include
- */
- void growToInclude(const GrRect& rect) {
- GrAssert(!rect.isEmpty());
- fLeft = GrMin(rect.fLeft, fLeft);
- fRight = GrMax(rect.fRight, fRight);
-
- fTop = GrMin(rect.fTop, fTop);
- fBottom = GrMax(rect.fBottom, fBottom);
- }
-
- /**
- * Sets this rect to the intersection with a clip rect. If there is no
- * intersection then this rect will be made empty.
- */
- bool intersectWith(const GrRect& clipRect) {
- if (fRight < clipRect.fLeft ||
- fLeft > clipRect.fRight ||
- fBottom < clipRect.fTop ||
- fTop > clipRect.fBottom) {
- this->setEmpty();
- return false;
- } else {
- fLeft = GrMax(fLeft, clipRect.fLeft);
- fRight = GrMin(fRight, clipRect.fRight);
- fTop = GrMax(fTop, clipRect.fTop);
- fBottom = GrMin(fBottom, clipRect.fBottom);
- return true;
- }
- }
-
- bool intersectWith(GrScalar left, GrScalar top,
- GrScalar right, GrScalar bottom) {
- if (fRight < left ||
- fLeft > right ||
- fBottom < top ||
- fTop > bottom) {
- this->setEmpty();
- return false;
- } else {
- fLeft = GrMax(fLeft, left);
- fRight = GrMin(fRight, right);
- fTop = GrMax(fTop, top);
- fBottom = GrMin(fBottom, bottom);
- return true;
- }
- }
-
- /**
- * Assigns 4 sequential points in order to construct a counter-clockwise
- * triangle fan, given the corners of this rect. Returns the address of
- * the next point, treating pts as an array.
- */
- GrPoint* setRectFan(GrPoint pts[4]) const {
- pts->setRectFan(fLeft, fTop, fRight, fBottom);
- return pts + 4;
- }
-
- /**
- * Swaps (left and right) and/or (top and bottom) if they are inverted
- */
- void sort() {
- if (fLeft > fRight) {
- GrScalar temp = fLeft;
- fLeft = fRight;
- fRight = temp;
- }
- if (fTop > fBottom) {
- GrScalar temp = fTop;
- fTop = fBottom;
- fBottom = temp;
- }
- }
-
- void translate(GrScalar tx, GrScalar ty) {
- fLeft += tx;
- fRight += tx;
-
- fTop += ty;
- fBottom += ty;
- }
-
- bool operator ==(const GrRect& r) const {
- return fLeft == r.fLeft &&
- fTop == r.fTop &&
- fRight == r.fRight &&
- fBottom == r.fBottom;
+ fLeft = SkToS16(r.fLeft);
+ fTop = SkToS16(r.fTop);
+ fRight = SkToS16(r.fRight);
+ fBottom = SkToS16(r.fBottom);
}
};
diff --git a/gpu/src/GrClip.cpp b/gpu/src/GrClip.cpp
index 425ad27..2d1680c 100644
--- a/gpu/src/GrClip.cpp
+++ b/gpu/src/GrClip.cpp
@@ -87,6 +87,12 @@
}
}
+static void intersectWith(SkRect* dst, const SkRect& src) {
+ if (!dst->intersect(src)) {
+ dst->setEmpty();
+ }
+}
+
void GrClip::setFromIterator(GrClipIterator* iter, GrScalar tx, GrScalar ty,
const GrRect* conservativeBounds) {
fList.reset();
@@ -118,7 +124,7 @@
rectCount = 1;
fList.pop_back();
GrAssert(kRect_ClipType == fList.back().fType);
- fList.back().fRect.intersectWith(e.fRect);
+ intersectWith(&fList.back().fRect, e.fRect);
}
} else {
isectRectValid = false;
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index ff3119a..8461187 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -550,7 +550,7 @@
// clip gets applied in second pass
target->disableState(GrDrawTarget::kClip_StateBit);
- GrIRect clear(0, 0, scale * boundW, scale * boundH);
+ GrIRect clear = SkIRect::MakeWH(scale * boundW, scale * boundH);
target->clear(&clear, 0x0);
return true;
@@ -590,15 +590,14 @@
scale * GR_Scalar1 / src->height());
sampler.setMatrix(sampleM);
target->setSamplerState(kOffscreenStage, sampler);
- GrRect rect(0, 0,
- scale * boundRect.width(),
- scale * boundRect.height());
+ GrRect rect = SkRect::MakeWH(scale * boundRect.width(),
+ scale * boundRect.height());
target->drawSimpleRect(rect, NULL, 1 << kOffscreenStage);
src = record->fEntry1->texture();
} else if (OffscreenRecord::kFSAA_Downsample == record->fDownsample) {
scale = 1;
- GrIRect rect(0, 0, boundRect.width(), boundRect.height());
+ GrIRect rect = SkIRect::MakeWH(boundRect.width(), boundRect.height());
src->asRenderTarget()->overrideResolveRect(rect);
} else {
GrAssert(OffscreenRecord::k4x4SinglePass_Downsample ==
@@ -624,8 +623,9 @@
sampler.preConcatMatrix(sampleM);
target->setSamplerState(kOffscreenStage, sampler);
- GrRect dstRect(boundRect);
+ GrRect dstRect;
int stages = (1 << kOffscreenStage) | (NULL == paint.getTexture() ? 0 : 1);
+ dstRect.set(boundRect);
target->drawSimpleRect(dstRect, NULL, stages);
this->unlockTexture(record->fEntry0);
@@ -840,6 +840,14 @@
0, 0, 16, aaStrokeRectIndexCount());
}
+/**
+ * Returns true if the rects edges are integer-aligned.
+ */
+static bool isIRect(const GrRect& r) {
+ return GrScalarIsInt(r.fLeft) && GrScalarIsInt(r.fTop) &&
+ GrScalarIsInt(r.fRight) && GrScalarIsInt(r.fBottom);
+}
+
static bool apply_aa_to_rect(GrDrawTarget* target,
GrGpu* gpu,
const GrPaint& paint,
@@ -884,7 +892,7 @@
devRect->sort();
if (width < 0) {
- return !devRect->isIRect();
+ return !isIRect(*devRect);
} else {
return true;
}
@@ -1163,13 +1171,12 @@
bool needsStencil = pr->requiresStencilPass(target, path, fill);
// compute bounds as intersection of rt size, clip, and path
- GrIRect bound(0, 0,
- target->getRenderTarget()->width(),
- target->getRenderTarget()->height());
+ GrIRect bound = SkIRect::MakeWH(target->getRenderTarget()->width(),
+ target->getRenderTarget()->height());
if (target->getClip().hasConservativeBounds()) {
GrIRect clipIBounds;
target->getClip().getConservativeBounds().roundOut(&clipIBounds);
- if (!bound.intersectWith(clipIBounds)) {
+ if (!bound.intersect(clipIBounds)) {
return;
}
}
@@ -1178,7 +1185,7 @@
GrIRect pathIBounds;
target->getViewMatrix().mapRect(&pathBounds, pathBounds);
pathBounds.roundOut(&pathIBounds);
- if (!bound.intersectWith(pathIBounds)) {
+ if (!bound.intersect(pathIBounds)) {
return;
}
}
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index 66105db..9950afd 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -399,7 +399,9 @@
GrIntToScalar(rt.width()), GrIntToScalar(rt.height()));
if (fClip.hasConservativeBounds()) {
bounds = fClip.getConservativeBounds();
- bounds.intersectWith(rtRect);
+ if (!bounds.intersect(rtRect)) {
+ bounds.setEmpty();
+ }
} else {
bounds = rtRect;
}
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index c63c766..e8c7afb 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -1175,10 +1175,9 @@
if (NULL != rect) {
// flushScissor expects rect to be clipped to the target.
r = *rect;
- GrIRect rtRect(0, 0,
- fCurrDrawState.fRenderTarget->width(),
- fCurrDrawState.fRenderTarget->height());
- if (r.intersectWith(rtRect)) {
+ GrIRect rtRect = SkIRect::MakeWH(fCurrDrawState.fRenderTarget->width(),
+ fCurrDrawState.fRenderTarget->height());
+ if (r.intersect(rtRect)) {
rect = &r;
} else {
return;
diff --git a/gpu/src/GrMatrix.cpp b/gpu/src/GrMatrix.cpp
index b169d19..c88c6e1 100644
--- a/gpu/src/GrMatrix.cpp
+++ b/gpu/src/GrMatrix.cpp
@@ -717,33 +717,3 @@
return count;
}
-///////////////////////////////////////////////////////////////////////////////
-#include "GrRect.h"
-
-void GrRect::setBounds(const GrPoint pts[], int count) {
- if (count <= 0) {
- this->setEmpty();
- } else {
- GrScalar L, R, T, B;
- L = R = pts[0].fX;
- T = B = pts[0].fY;
- for (int i = 1; i < count; i++) {
- GrScalar x = pts[i].fX;
- GrScalar y = pts[i].fY;
- if (x < L) {
- L = x;
- } else if (x > R) {
- R = x;
- }
- if (y < T) {
- T = y;
- } else if (y > B) {
- B = y;
- }
- }
- this->setLTRB(L, T, R, B);
- }
-}
-
-
-
diff --git a/gpu/src/GrPath.cpp b/gpu/src/GrPath.cpp
index 3687b80..aa89d37 100644
--- a/gpu/src/GrPath.cpp
+++ b/gpu/src/GrPath.cpp
@@ -104,7 +104,7 @@
iter->offset(tx, ty);
++iter;
}
- fConservativeBounds.translate(tx, ty);
+ fConservativeBounds.offset(tx, ty);
}
///////////////////////////////////////////////////////////////////////////////
@@ -221,7 +221,7 @@
}
int n = NumPathCmdPoints(cmd);
for (int i = 0; i < n; ++i) {
- fConservativeBounds.growToInclude(pts[i]);
+ fConservativeBounds.growToInclude(pts[i].fX, pts[i].fY);
}
if (0 == subPathPts && n > 0) {
previousPt = pts[0];
@@ -423,6 +423,13 @@
this->rewind();
}
+#ifdef SK_DEBUG
+static bool containsInclusive(const GrRect& rect, const GrPoint& point) {
+ return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
+ point.fY >= rect.fTop && point.fY <= rect.fBottom;
+}
+#endif
+
GrPathCmd GrPath::Iter::next(GrPoint points[]) {
if (fCmdIndex == fPath->fCmds.count()) {
GrAssert(fPtIndex == fPath->fPts.count());
@@ -441,7 +448,7 @@
}
fLastPt = srcPts[0];
GrAssert(fPtIndex <= fPath->fPts.count() + 1);
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[0]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
fPtIndex += 1;
break;
case kLine_PathCmd:
@@ -451,7 +458,7 @@
}
fLastPt = srcPts[0];
GrAssert(fPtIndex <= fPath->fPts.count() + 1);
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[0]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
fPtIndex += 1;
break;
case kQuadratic_PathCmd:
@@ -462,8 +469,8 @@
}
fLastPt = srcPts[1];
GrAssert(fPtIndex <= fPath->fPts.count() + 2);
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[0]));
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[1]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[1]));
fPtIndex += 2;
break;
case kCubic_PathCmd:
@@ -475,9 +482,9 @@
}
fLastPt = srcPts[2];
GrAssert(fPtIndex <= fPath->fPts.count() + 3);
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[0]));
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[1]));
- GrAssert(fPath->getConservativeBounds().containsInclusive(srcPts[2]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[0]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[1]));
+ GrAssert(containsInclusive(fPath->getConservativeBounds(), srcPts[2]));
fPtIndex += 3;
break;
case kClose_PathCmd:
diff --git a/gpu/src/GrTexture.cpp b/gpu/src/GrTexture.cpp
index 8ee531c..8df9c9e 100644
--- a/gpu/src/GrTexture.cpp
+++ b/gpu/src/GrTexture.cpp
@@ -32,8 +32,10 @@
void GrRenderTarget::flagAsNeedingResolve(const GrIRect* rect) {
if (kCanResolve_ResolveType == getResolveType()) {
if (NULL != rect) {
- fResolveRect.growToInclude(*rect);
- fResolveRect.intersectWith(0, 0, this->width(), this->height());
+ fResolveRect.join(*rect);
+ if (!fResolveRect.intersect(0, 0, this->width(), this->height())) {
+ fResolveRect.setEmpty();
+ }
} else {
fResolveRect.setLTRB(0, 0, this->width(), this->height());
}
@@ -45,7 +47,7 @@
if (fResolveRect.isEmpty()) {
fResolveRect.setLargestInverted();
} else {
- if (!fResolveRect.intersectWith(0, 0, this->width(), this->height())) {
+ if (!fResolveRect.intersect(0, 0, this->width(), this->height())) {
fResolveRect.setLargestInverted();
}
}