move some RRect methods into priv
also, return radii by value instead of reference, in possible prep for changing underlying representation
Bug: skia:7649
Change-Id: Iff42a49c53cc48171fc63462be366cc3500b2273
Reviewed-on: https://skia-review.googlesource.com/109385
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/core/SkRRect.cpp b/src/core/SkRRect.cpp
index c6a0f0a..a8ed724 100644
--- a/src/core/SkRRect.cpp
+++ b/src/core/SkRRect.cpp
@@ -6,7 +6,7 @@
*/
#include <cmath>
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkScopeExit.h"
#include "SkBuffer.h"
#include "SkMalloc.h"
@@ -257,11 +257,11 @@
return dist <= SkScalarSquare(fRadii[index].fX * fRadii[index].fY);
}
-bool SkRRect::allCornersCircular(SkScalar tolerance) const {
- return SkScalarNearlyEqual(fRadii[0].fX, fRadii[0].fY, tolerance) &&
- SkScalarNearlyEqual(fRadii[1].fX, fRadii[1].fY, tolerance) &&
- SkScalarNearlyEqual(fRadii[2].fX, fRadii[2].fY, tolerance) &&
- SkScalarNearlyEqual(fRadii[3].fX, fRadii[3].fY, tolerance);
+bool SkRRectPriv::AllCornersCircular(const SkRRect& rr, SkScalar tolerance) {
+ return SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY, tolerance) &&
+ SkScalarNearlyEqual(rr.fRadii[1].fX, rr.fRadii[1].fY, tolerance) &&
+ SkScalarNearlyEqual(rr.fRadii[2].fX, rr.fRadii[2].fY, tolerance) &&
+ SkScalarNearlyEqual(rr.fRadii[3].fX, rr.fRadii[3].fY, tolerance);
}
bool SkRRect::contains(const SkRect& rect) const {
diff --git a/src/core/SkRRectPriv.h b/src/core/SkRRectPriv.h
new file mode 100644
index 0000000..ea277f7
--- /dev/null
+++ b/src/core/SkRRectPriv.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkRRectPriv_DEFINED
+#define SkRRectPriv_DEFINED
+
+#include "SkRRect.h"
+
+class SkRRectPriv {
+public:
+ static bool IsCircle(const SkRRect& rr) {
+ return rr.isOval() && SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY);
+ }
+
+ static SkVector GetSimpleRadii(const SkRRect& rr) {
+ SkASSERT(!rr.isComplex());
+ return rr.fRadii[0];
+ }
+
+ static bool IsSimpleCircular(const SkRRect& rr) {
+ return rr.isSimple() && SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY);
+ }
+
+ static bool EqualRadii(const SkRRect& rr) {
+ return rr.isRect() || SkRRectPriv::IsCircle(rr) || SkRRectPriv::IsSimpleCircular(rr);
+ }
+
+ static bool AllCornersCircular(const SkRRect& rr, SkScalar tolerance = SK_ScalarNearlyZero);
+};
+
+#endif
+
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 7992d97..9d7df43 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -10,6 +10,7 @@
#include "SkGpuBlurUtils.h"
#include "SkMaskFilterBase.h"
#include "SkReadBuffer.h"
+#include "SkRRectPriv.h"
#include "SkWriteBuffer.h"
#include "SkMaskFilter.h"
#include "SkRRect.h"
@@ -828,7 +829,7 @@
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
- if (devRRect.isRect() || devRRect.isCircle()) {
+ if (devRRect.isRect() || SkRRectPriv::IsCircle(devRRect)) {
std::unique_ptr<GrFragmentProcessor> fp;
if (devRRect.isRect()) {
SkScalar pad = 3.0f * xformedSigma;
@@ -924,7 +925,7 @@
}
// We always do circles and simple circular rrects on the GPU
- if (!devRRect.isCircle() && !devRRect.isSimpleCircular()) {
+ if (!SkRRectPriv::IsCircle(devRRect) && !SkRRectPriv::IsSimpleCircular(devRRect)) {
static const SkScalar kMIN_GPU_BLUR_SIZE = SkIntToScalar(64);
static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
diff --git a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
index 850e440..856076f 100644
--- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
+++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
@@ -8,7 +8,7 @@
#include "SkMaskFilterBase.h"
#include "SkRRectsGaussianEdgeMaskFilter.h"
#include "SkReadBuffer.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkWriteBuffer.h"
#if SK_SUPPORT_GPU
@@ -66,7 +66,7 @@
SkScalar halfH = 0.5f * rr.rect().height();
SkScalar invRad = 1.0f/rad;
- const SkVector& radii = rr.getSimpleRadii();
+ const SkVector& radii = SkRRectPriv::GetSimpleRadii(rr);
SkASSERT(SkScalarNearlyEqual(radii.fX, radii.fY));
switch (rr.getType()) {
@@ -428,8 +428,10 @@
// This is a bit of overkill since fX should equal fY for both round rects but it
// makes the shader code simpler.
pdman.set4f(fRadiiUni,
- first.getSimpleRadii().fX, first.getSimpleRadii().fY,
- second.getSimpleRadii().fX, second.getSimpleRadii().fY);
+ SkRRectPriv::GetSimpleRadii(first).fX,
+ SkRRectPriv::GetSimpleRadii(first).fY,
+ SkRRectPriv::GetSimpleRadii(second).fX,
+ SkRRectPriv::GetSimpleRadii(second).fY);
}
pdman.set1f(fRadiusUni, edgeFP.radius());
@@ -480,12 +482,12 @@
}
static Mode ComputeMode(const SkRRect& rr) {
- if (rr.isCircle()) {
+ if (SkRRectPriv::IsCircle(rr)) {
return kCircle_Mode;
} else if (rr.isRect()) {
return kRect_Mode;
} else {
- SkASSERT(rr.isSimpleCircular());
+ SkASSERT(SkRRectPriv::IsSimpleCircular(rr));
return kSimpleCircular_Mode;
}
}
@@ -548,15 +550,15 @@
void SkRRectsGaussianEdgeMaskFilterImpl::flatten(SkWriteBuffer& buf) const {
INHERITED::flatten(buf);
- SkASSERT(fFirst.isRect() || fFirst.isCircle() || fFirst.isSimpleCircular());
+ SkASSERT(SkRRectPriv::EqualRadii(fFirst));
buf.writeRect(fFirst.rect());
- const SkVector& radii1 = fFirst.getSimpleRadii();
+ const SkVector radii1 = SkRRectPriv::GetSimpleRadii(fFirst);
buf.writeScalar(radii1.fX);
buf.writeScalar(radii1.fY);
- SkASSERT(fSecond.isRect() || fSecond.isCircle() || fSecond.isSimpleCircular());
+ SkASSERT(SkRRectPriv::EqualRadii(fSecond));
buf.writeRect(fSecond.rect());
- const SkVector& radii2 = fSecond.getSimpleRadii();
+ const SkVector radii2 = SkRRectPriv::GetSimpleRadii(fSecond);
buf.writeScalar(radii2.fX);
buf.writeScalar(radii2.fY);
@@ -568,8 +570,7 @@
sk_sp<SkMaskFilter> SkRRectsGaussianEdgeMaskFilter::Make(const SkRRect& first,
const SkRRect& second,
SkScalar radius) {
- if ((!first.isRect() && !first.isCircle() && !first.isSimpleCircular()) ||
- (!second.isRect() && !second.isCircle() && !second.isSimpleCircular())) {
+ if (!SkRRectPriv::EqualRadii(first) || !SkRRectPriv::EqualRadii(second)) {
// we only deal with the shapes where the x & y radii are equal
// and the same for all four corners
return nullptr;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 89f0b8a..1de4ab8 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -28,6 +28,7 @@
#include "SkGr.h"
#include "SkLatticeIter.h"
#include "SkMatrixPriv.h"
+#include "SkRRectPriv.h"
#include "SkShadowUtils.h"
#include "SkSurfacePriv.h"
#include "effects/GrRRectEffect.h"
@@ -965,7 +966,7 @@
SkRRect rrect;
SkRect rect;
// we can only handle rects, circles, and rrects with circular corners
- bool isRRect = path.isRRect(&rrect) && rrect.isSimpleCircular() &&
+ bool isRRect = path.isRRect(&rrect) && SkRRectPriv::IsSimpleCircular(rrect) &&
rrect.radii(SkRRect::kUpperLeft_Corner).fX > SK_ScalarNearlyZero;
if (!isRRect &&
path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height()) &&
@@ -1014,7 +1015,7 @@
if (rrect.isOval()) {
ambientRRect = SkRRect::MakeOval(outsetRect);
} else {
- SkScalar outsetRad = rrect.getSimpleRadii().fX + ambientPathOutset;
+ SkScalar outsetRad = SkRRectPriv::GetSimpleRadii(rrect).fX + ambientPathOutset;
ambientRRect = SkRRect::MakeRectXY(outsetRect, outsetRad, outsetRad);
}
@@ -1064,7 +1065,7 @@
SkMatrix shadowTransform;
shadowTransform.setScaleTranslate(spotScale, spotScale, spotOffset.fX, spotOffset.fY);
rrect.transform(shadowTransform, &spotShadowRRect);
- SkScalar spotRadius = spotShadowRRect.getSimpleRadii().fX;
+ SkScalar spotRadius = SkRRectPriv::GetSimpleRadii(spotShadowRRect).fX;
// Compute the insetWidth
SkScalar blurOutset = srcSpaceSpotBlur;
@@ -1097,7 +1098,7 @@
SkTAbs(spotShadowRRect.rect().fBottom -
rrect.rect().fBottom)));
} else {
- SkScalar dr = spotRadius - rrect.getSimpleRadii().fX;
+ SkScalar dr = spotRadius - SkRRectPriv::GetSimpleRadii(rrect).fX;
SkPoint upperLeftOffset = SkPoint::Make(spotShadowRRect.rect().fLeft -
rrect.rect().fLeft + dr,
spotShadowRRect.rect().fTop -
@@ -1153,7 +1154,8 @@
return false;
}
- if (GrAAType::kCoverage == aaType && inner->isCircle() && outer->isCircle()) {
+ if (GrAAType::kCoverage == aaType && SkRRectPriv::IsCircle(*inner)
+ && SkRRectPriv::IsCircle(*outer)) {
auto outerR = outer->width() / 2.f;
auto innerR = inner->width() / 2.f;
auto cx = outer->getBounds().fLeft + outerR;
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index bc5a34b..1a4538a 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -32,7 +32,7 @@
#include "SkPathEffect.h"
#include "SkPicture.h"
#include "SkPictureData.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkRasterClip.h"
#include "SkReadPixelsRec.h"
#include "SkRecord.h"
@@ -418,7 +418,7 @@
SkRRect devRRect;
if (rrect.transform(this->ctm(), &devRRect)) {
- if (devRRect.allCornersCircular()) {
+ if (SkRRectPriv::AllCornersCircular(devRRect)) {
if (mf->canFilterMaskGPU(devRRect, this->devClipBounds(), this->ctm(), nullptr)) {
if (mf->directFilterRRectMaskGPU(this->context(), fRenderTargetContext.get(),
std::move(grPaint), this->clip(), this->ctm(),
diff --git a/src/gpu/effects/GrRRectBlurEffect.cpp b/src/gpu/effects/GrRRectBlurEffect.cpp
index e83ef17..b307946 100644
--- a/src/gpu/effects/GrRRectBlurEffect.cpp
+++ b/src/gpu/effects/GrRRectBlurEffect.cpp
@@ -15,10 +15,11 @@
float xformedSigma,
const SkRRect& srcRRect,
const SkRRect& devRRect) {
- SkASSERT(!devRRect.isCircle() && !devRRect.isRect()); // Should've been caught up-stream
+ SkASSERT(!SkRRectPriv::IsCircle(devRRect) &&
+ !devRRect.isRect()); // Should've been caught up-stream
// TODO: loosen this up
- if (!devRRect.isSimpleCircular()) {
+ if (!SkRRectPriv::IsSimpleCircular(devRRect)) {
return nullptr;
}
@@ -44,8 +45,9 @@
return nullptr;
}
- return std::unique_ptr<GrFragmentProcessor>(new GrRRectBlurEffect(
- xformedSigma, devRRect.getBounds(), devRRect.getSimpleRadii().fX, std::move(mask)));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrRRectBlurEffect(xformedSigma, devRRect.getBounds(),
+ SkRRectPriv::GetSimpleRadii(devRRect).fX, std::move(mask)));
}
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
diff --git a/src/gpu/effects/GrRRectBlurEffect.fp b/src/gpu/effects/GrRRectBlurEffect.fp
index 3f817d5..5015cd0 100644
--- a/src/gpu/effects/GrRRectBlurEffect.fp
+++ b/src/gpu/effects/GrRRectBlurEffect.fp
@@ -22,6 +22,7 @@
#include "GrStyle.h"
#include "SkBlurMaskFilter.h"
#include "SkGpuBlurUtils.h"
+ #include "SkRRectPriv.h"
}
@class {
@@ -108,10 +109,10 @@
float xformedSigma,
const SkRRect& srcRRect,
const SkRRect& devRRect) {
- SkASSERT(!devRRect.isCircle() && !devRRect.isRect()); // Should've been caught up-stream
+ SkASSERT(!SkRRectPriv::IsCircle(devRRect) && !devRRect.isRect()); // Should've been caught up-stream
// TODO: loosen this up
- if (!devRRect.isSimpleCircular()) {
+ if (!SkRRectPriv::IsSimpleCircular(devRRect)) {
return nullptr;
}
@@ -144,7 +145,7 @@
return std::unique_ptr<GrFragmentProcessor>(
new GrRRectBlurEffect(xformedSigma, devRRect.getBounds(),
- devRRect.getSimpleRadii().fX, std::move(mask)));
+ SkRRectPriv::GetSimpleRadii(devRRect).fX, std::move(mask)));
}
}
diff --git a/src/gpu/effects/GrRRectBlurEffect.h b/src/gpu/effects/GrRRectBlurEffect.h
index 3fd6f0c..7ba02c7 100644
--- a/src/gpu/effects/GrRRectBlurEffect.h
+++ b/src/gpu/effects/GrRRectBlurEffect.h
@@ -22,6 +22,7 @@
#include "GrStyle.h"
#include "SkBlurMaskFilter.h"
#include "SkGpuBlurUtils.h"
+#include "SkRRectPriv.h"
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
class GrRRectBlurEffect : public GrFragmentProcessor {
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index c6430ab..2fb28fd 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -11,7 +11,7 @@
#include "GrFragmentProcessor.h"
#include "GrOvalEffect.h"
#include "GrShaderCaps.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkTLazy.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
@@ -298,8 +298,8 @@
SkScalar radius = 0;
switch (crre.getCircularCornerFlags()) {
case CircularRRectEffect::kAll_CornerFlags:
- SkASSERT(rrect.isSimpleCircular());
- radius = rrect.getSimpleRadii().fX;
+ SkASSERT(SkRRectPriv::IsSimpleCircular(rrect));
+ radius = SkRRectPriv::GetSimpleRadii(rrect).fX;
SkASSERT(radius >= kRadiusMin);
rect.inset(radius, radius);
break;
@@ -680,12 +680,13 @@
}
if (rrect.isSimple()) {
- if (rrect.getSimpleRadii().fX < kRadiusMin || rrect.getSimpleRadii().fY < kRadiusMin) {
+ if (SkRRectPriv::GetSimpleRadii(rrect).fX < kRadiusMin ||
+ SkRRectPriv::GetSimpleRadii(rrect).fY < kRadiusMin) {
// In this case the corners are extremely close to rectangular and we collapse the
// clip to a rectangular clip.
return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
}
- if (rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY) {
+ if (SkRRectPriv::GetSimpleRadii(rrect).fX == SkRRectPriv::GetSimpleRadii(rrect).fY) {
return CircularRRectEffect::Make(edgeType, CircularRRectEffect::kAll_CornerFlags,
rrect);
} else {
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index ecaa30d..b931869 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -13,7 +13,7 @@
#include "GrResourceProvider.h"
#include "GrShaderCaps.h"
#include "GrStyle.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkStrokeRec.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLGeometryProcessor.h"
@@ -2317,7 +2317,7 @@
SkRect bounds;
viewMatrix.mapRect(&bounds, rrectBounds);
- SkVector radii = rrect.getSimpleRadii();
+ SkVector radii = SkRRectPriv::GetSimpleRadii(rrect);
SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX] * radii.fX +
viewMatrix[SkMatrix::kMSkewY] * radii.fY);
SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX] * radii.fX +
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 24bbff4..ba96941 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -8,7 +8,7 @@
#include "GrShadowRRectOp.h"
#include "GrDrawOpTest.h"
#include "GrOpFlushState.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "effects/GrShadowGeoProc.h"
///////////////////////////////////////////////////////////////////////////////
@@ -651,8 +651,7 @@
SkScalar insetWidth,
SkScalar blurClamp) {
// Shadow rrect ops only handle simple circular rrects.
- SkASSERT(viewMatrix.isSimilarity() &&
- (rrect.isSimpleCircular() || rrect.isRect() || rrect.isCircle()));
+ SkASSERT(viewMatrix.isSimilarity() && SkRRectPriv::EqualRadii(rrect));
// Do any matrix crunching before we reset the draw state for device coords.
const SkRect& rrectBounds = rrect.getBounds();
@@ -660,7 +659,7 @@
viewMatrix.mapRect(&bounds, rrectBounds);
// Map radius and inset. As the matrix is a similarity matrix, this should be isotropic.
- SkScalar radius = rrect.getSimpleRadii().fX;
+ SkScalar radius = SkRRectPriv::GetSimpleRadii(rrect).fX;
SkScalar matrixFactor = viewMatrix[SkMatrix::kMScaleX] + viewMatrix[SkMatrix::kMSkewX];
SkScalar scaledRadius = SkScalarAbs(radius*matrixFactor);
SkScalar scaledInsetWidth = SkScalarAbs(insetWidth*matrixFactor);
@@ -703,7 +702,7 @@
do {
// This may return a rrect with elliptical corners, which we don't support.
rrect = GrTest::TestRRectSimple(random);
- } while (!rrect.isSimpleCircular());
+ } while (!SkRRectPriv::IsSimpleCircular(rrect));
return GrShadowRRectOp::Make(color, viewMatrix, rrect, blurWidth, insetWidth, blurClamp);
}
}
diff --git a/src/utils/SkDumpCanvas.cpp b/src/utils/SkDumpCanvas.cpp
index c547fa2..b7c200f 100644
--- a/src/utils/SkDumpCanvas.cpp
+++ b/src/utils/SkDumpCanvas.cpp
@@ -13,7 +13,7 @@
#include "SkPicture.h"
#include "SkPixelRef.h"
#include "SkRegion.h"
-#include "SkRRect.h"
+#include "SkRRectPriv.h"
#include "SkString.h"
#include "SkTextBlob.h"
#include <stdarg.h>
@@ -44,7 +44,7 @@
if (rrect.isOval()) {
str->append("()");
} else if (rrect.isSimple()) {
- const SkVector& rad = rrect.getSimpleRadii();
+ const SkVector rad = SkRRectPriv::GetSimpleRadii(rrect);
str->appendf("(%g,%g)", rad.x(), rad.y());
} else if (rrect.isComplex()) {
SkVector radii[4] = {