Stateful PathRenderer implementation
https://codereview.chromium.org/23926019/
git-svn-id: http://skia.googlecode.com/svn/trunk@13384 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index ad3789b..8feea81 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -854,7 +854,8 @@
const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool allowSW,
- GrPathRendererChain::DrawType drawType = GrPathRendererChain::kColor_DrawType,
+ GrPathRendererChain::DrawType drawType,
+ SkPath::FillType fillType,
GrPathRendererChain::StencilSupport* stencilSupport = NULL);
diff --git a/include/gpu/GrPathRendererChain.h b/include/gpu/GrPathRendererChain.h
index ca8c35b..76fd1da 100644
--- a/include/gpu/GrPathRendererChain.h
+++ b/include/gpu/GrPathRendererChain.h
@@ -8,6 +8,7 @@
#ifndef GrPathRendererChain_DEFINED
#define GrPathRendererChain_DEFINED
+#include "SkPath.h"
#include "SkRefCnt.h"
#include "SkTArray.h"
@@ -59,6 +60,7 @@
const SkStrokeRec& rec,
const GrDrawTarget* target,
DrawType drawType,
+ SkPath::FillType fillType,
StencilSupport* stencilSupport);
private:
diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp
index a8af559..0a11661 100644
--- a/src/gpu/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/GrAAConvexPathRenderer.cpp
@@ -605,12 +605,11 @@
///////////////////////////////////////////////////////////////////////////////
-bool GrAAConvexPathRenderer::canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrAAConvexPathRenderer::canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const {
return (target->caps()->shaderDerivativeSupport() && antiAlias &&
- stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
+ stroke.isFillStyle() && !this->path().isInverseFillType() && this->path().isConvex());
}
namespace {
@@ -623,12 +622,11 @@
};
-bool GrAAConvexPathRenderer::onDrawPath(const SkPath& origPath,
- const SkStrokeRec&,
+bool GrAAConvexPathRenderer::onDrawPath(const SkStrokeRec&,
GrDrawTarget* target,
bool antiAlias) {
- const SkPath* path = &origPath;
+ const SkPath* path = &this->path();
if (path->isEmpty()) {
return true;
}
@@ -645,7 +643,7 @@
// segment representation.
SkPath tmpPath;
if (viewMatrix.hasPerspective()) {
- origPath.transform(viewMatrix, &tmpPath);
+ this->path().transform(viewMatrix, &tmpPath);
path = &tmpPath;
viewMatrix = SkMatrix::I();
}
diff --git a/src/gpu/GrAAConvexPathRenderer.h b/src/gpu/GrAAConvexPathRenderer.h
index 62394a3..61e5472 100644
--- a/src/gpu/GrAAConvexPathRenderer.h
+++ b/src/gpu/GrAAConvexPathRenderer.h
@@ -13,14 +13,15 @@
public:
GrAAConvexPathRenderer();
- virtual bool canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ virtual bool canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const SK_OVERRIDE;
protected:
- virtual bool onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ virtual bool onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) SK_OVERRIDE;
+
+private:
+ typedef GrPathRenderer INHERITED;
};
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index 830f513..7f15266 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -826,8 +826,7 @@
return true;
}
-bool GrAAHairLinePathRenderer::canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrAAHairLinePathRenderer::canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const {
if (!antiAlias) {
@@ -840,7 +839,7 @@
return false;
}
- if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
+ if (SkPath::kLine_SegmentMask == this->path().getSegmentMasks() ||
target->caps()->shaderDerivativeSupport()) {
return true;
}
@@ -884,8 +883,7 @@
return true;
}
-bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrAAHairLinePathRenderer::onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
GrDrawState* drawState = target->drawState();
@@ -910,7 +908,7 @@
PREALLOC_PTARRAY(128) conics;
IntArray qSubdivs;
FloatArray cWeights;
- quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
+ quadCnt = generate_lines_and_quads(this->path(), drawState->getViewMatrix(), devClipBounds,
&lines, &quads, &conics, &qSubdivs, &cWeights);
lineCnt = lines.count() / 2;
conicCnt = conics.count() / 3;
@@ -920,7 +918,7 @@
GrDrawTarget::AutoReleaseGeometry arg;
SkRect devBounds;
- if (!this->createLineGeom(path,
+ if (!this->createLineGeom(this->path(),
target,
lines,
lineCnt,
@@ -966,7 +964,7 @@
GrDrawTarget::AutoReleaseGeometry arg;
SkRect devBounds;
- if (!this->createBezierGeom(path,
+ if (!this->createBezierGeom(this->path(),
target,
quads,
quadCnt,
diff --git a/src/gpu/GrAAHairLinePathRenderer.h b/src/gpu/GrAAHairLinePathRenderer.h
index 22cc876..627474a 100644
--- a/src/gpu/GrAAHairLinePathRenderer.h
+++ b/src/gpu/GrAAHairLinePathRenderer.h
@@ -17,8 +17,7 @@
static GrPathRenderer* Create(GrContext* context);
- virtual bool canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ virtual bool canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const SK_OVERRIDE;
@@ -27,8 +26,7 @@
typedef SkTArray<float, true> FloatArray;
protected:
- virtual bool onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ virtual bool onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) SK_OVERRIDE;
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index caee6eb..35e0818 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -30,12 +30,11 @@
using namespace GrReducedClip;
////////////////////////////////////////////////////////////////////////////////
-namespace {
// set up the draw state to enable the aa clipping mask. Besides setting up the
// stage matrix this also alters the vertex layout
-void setup_drawstate_aaclip(GrGpu* gpu,
- GrTexture* result,
- const SkIRect &devBound) {
+static void setup_drawstate_aaclip(GrGpu* gpu,
+ GrTexture* result,
+ const SkIRect &devBound) {
GrDrawState* drawState = gpu->drawState();
SkASSERT(drawState);
@@ -59,24 +58,21 @@
kPosition_GrCoordSet))->unref();
}
-bool path_needs_SW_renderer(GrContext* context,
- GrGpu* gpu,
- const SkPath& origPath,
- const SkStrokeRec& stroke,
- bool doAA) {
- // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
- SkTCopyOnFirstWrite<SkPath> path(origPath);
- if (path->isInverseFillType()) {
- path.writable()->toggleInverseFillType();
- }
- // last (false) parameter disallows use of the SW path renderer
+static bool path_needs_SW_renderer(GrContext* context,
+ GrGpu* gpu,
+ const SkPath& origPath,
+ const SkStrokeRec& stroke,
+ bool doAA) {
GrPathRendererChain::DrawType type = doAA ?
GrPathRendererChain::kColorAntiAlias_DrawType :
GrPathRendererChain::kColor_DrawType;
+ // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
+ SkPath::FillType fillType = SkPath::ConvertToNonInverseFillType(origPath.getFillType());
- return NULL == context->getPathRenderer(*path, stroke, gpu, false, type);
-}
-
+ // the 'false' parameter disallows use of the SW path renderer
+ GrPathRenderer::AutoClearPath acp(context->getPathRenderer(origPath, stroke, gpu,
+ false, type, fillType));
+ return NULL == acp.renderer();
}
/*
@@ -313,9 +309,20 @@
}
////////////////////////////////////////////////////////////////////////////////
+bool GrClipMaskManager::drawFilledPath(GrTexture* target,
+ GrPathRenderer* pathRenderer,
+ bool isAA) {
+ GrDrawState* drawState = fGpu->drawState();
+
+ drawState->setRenderTarget(target->asRenderTarget());
+
+ SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
+ pathRenderer->drawPath(stroke, fGpu, isAA);
+ return true;
+}
+
bool GrClipMaskManager::drawElement(GrTexture* target,
- const SkClipStack::Element* element,
- GrPathRenderer* pr) {
+ const SkClipStack::Element* element) {
GrDrawState* drawState = fGpu->drawState();
drawState->setRenderTarget(target->asRenderTarget());
@@ -336,21 +343,19 @@
}
return true;
case Element::kPath_Type: {
- SkTCopyOnFirstWrite<SkPath> path(element->getPath());
- if (path->isInverseFillType()) {
- path.writable()->toggleInverseFillType();
- }
SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
- if (NULL == pr) {
- GrPathRendererChain::DrawType type;
- type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
- GrPathRendererChain::kColor_DrawType;
- pr = this->getContext()->getPathRenderer(*path, stroke, fGpu, false, type);
- }
- if (NULL == pr) {
+ GrPathRendererChain::DrawType type;
+ type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
+ GrPathRendererChain::kColor_DrawType;
+ SkPath::FillType fillType = element->getPath().getFillType();
+ GrPathRenderer::AutoClearPath acp(this->getContext()->getPathRenderer(
+ element->getPath(),
+ stroke, fGpu, false, type,
+ SkPath::ConvertToNonInverseFillType(fillType)));
+ if (NULL == acp.renderer()) {
return false;
}
- pr->drawPath(element->getPath(), stroke, fGpu, element->isAA());
+ acp->drawPath(stroke, fGpu, element->isAA());
break;
}
default:
@@ -363,7 +368,7 @@
bool GrClipMaskManager::canStencilAndDrawElement(GrTexture* target,
const SkClipStack::Element* element,
- GrPathRenderer** pr) {
+ GrPathRenderer::AutoClearPath* acp) {
GrDrawState* drawState = fGpu->drawState();
drawState->setRenderTarget(target->asRenderTarget());
@@ -371,16 +376,15 @@
case Element::kRect_Type:
return true;
case Element::kPath_Type: {
- SkTCopyOnFirstWrite<SkPath> path(element->getPath());
- if (path->isInverseFillType()) {
- path.writable()->toggleInverseFillType();
- }
SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
GrPathRendererChain::DrawType type = element->isAA() ?
GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
GrPathRendererChain::kStencilAndColor_DrawType;
- *pr = this->getContext()->getPathRenderer(*path, stroke, fGpu, false, type);
- return NULL != *pr;
+ SkPath::FillType fillType = element->getPath().getFillType();
+ acp->set(this->getContext()->getPathRenderer(element->getPath(),
+ stroke, fGpu, false, type,
+ SkPath::ConvertToNonInverseFillType(fillType)));
+ return NULL != acp->renderer();
}
default:
// something is wrong if we're trying to draw an empty element.
@@ -525,8 +529,8 @@
bool invert = element->isInverseFilled();
if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
- GrPathRenderer* pr = NULL;
- bool useTemp = !this->canStencilAndDrawElement(result, element, &pr);
+ GrPathRenderer::AutoClearPath acp;
+ bool useTemp = !this->canStencilAndDrawElement(result, element, &acp);
GrTexture* dst;
// This is the bounds of the clip element in the space of the alpha-mask. The temporary
// mask buffer can be substantially larger than the actually clip stack element. We
@@ -573,9 +577,13 @@
drawState->setAlpha(invert ? 0x00 : 0xff);
- if (!this->drawElement(dst, element, pr)) {
- fAACache.reset();
- return NULL;
+ if (NULL != acp.renderer()) {
+ this->drawFilledPath(dst, acp.renderer(), element->isAA());
+ } else {
+ if (!this->drawElement(dst, element)) {
+ fAACache.reset();
+ return NULL;
+ }
}
if (useTemp) {
@@ -601,7 +609,7 @@
drawState->disableStencil();
}
} else {
- // all the remaining ops can just be directly draw into the accumulation buffer
+ // all the remaining ops can just be directly drawn into the accumulation buffer
drawState->setAlpha(0xff);
setup_boolean_blendcoeffs(drawState, op);
this->drawElement(result, element);
@@ -687,25 +695,22 @@
SkRegion::Op op = element->getOp();
- GrPathRenderer* pr = NULL;
- SkTCopyOnFirstWrite<SkPath> clipPath;
+ GrPathRenderer::AutoClearPath acp;
if (Element::kRect_Type == element->getType()) {
stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
fillInverted = false;
} else {
SkASSERT(Element::kPath_Type == element->getType());
- clipPath.init(element->getPath());
- fillInverted = clipPath->isInverseFillType();
- if (fillInverted) {
- clipPath.writable()->toggleInverseFillType();
- }
- pr = this->getContext()->getPathRenderer(*clipPath,
+ fillInverted = element->getPath().isInverseFillType();
+ SkPath::FillType fill = element->getPath().getFillType();
+ acp.set(this->getContext()->getPathRenderer(element->getPath(),
stroke,
fGpu,
false,
GrPathRendererChain::kStencilOnly_DrawType,
- &stencilSupport);
- if (NULL == pr) {
+ SkPath::ConvertToNonInverseFillType(fill),
+ &stencilSupport));
+ if (NULL == acp.renderer()) {
return false;
}
}
@@ -741,12 +746,12 @@
fGpu->drawSimpleRect(element->getRect(), NULL);
} else {
SkASSERT(Element::kPath_Type == element->getType());
- if (!clipPath->isEmpty()) {
+ if (NULL != acp.renderer()) {
if (canRenderDirectToStencil) {
*drawState->stencil() = gDrawToStencil;
- pr->drawPath(*clipPath, stroke, fGpu, false);
+ acp->drawPath(stroke, fGpu, false);
} else {
- pr->stencilPath(*clipPath, stroke, fGpu);
+ acp->stencilPath(stroke, fGpu);
}
}
}
@@ -764,7 +769,7 @@
} else {
SkASSERT(Element::kPath_Type == element->getType());
SET_RANDOM_COLOR
- pr->drawPath(*clipPath, stroke, fGpu, false);
+ acp->drawPath(stroke, fGpu, false);
}
} else {
SET_RANDOM_COLOR
diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h
index f44a8e7..fa54f3c 100644
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipMaskManager.h
@@ -11,6 +11,7 @@
#include "GrClipMaskCache.h"
#include "GrContext.h"
#include "GrDrawState.h"
+#include "GrPathRenderer.h"
#include "GrReducedClip.h"
#include "GrStencil.h"
#include "GrTexture.h"
@@ -130,15 +131,18 @@
bool useSWOnlyPath(const GrReducedClip::ElementList& elements);
+ // Draws a filled clip path into the target alpha mask
+ bool drawFilledPath(GrTexture* target, GrPathRenderer* pathRenderer, bool isAA);
+
// Draws a clip element into the target alpha mask. The caller should have already setup the
- // desired blend operation. Optionally if the caller already selected a path renderer it can
- // be passed. Otherwise the function will select one if the element is a path.
- bool drawElement(GrTexture* target, const SkClipStack::Element*, GrPathRenderer* = NULL);
+ // desired blend operation.
+ bool drawElement(GrTexture* target, const SkClipStack::Element* element);
// Determines whether it is possible to draw the element to both the stencil buffer and the
// alpha mask simultaneously. If so and the element is a path a compatible path renderer is
// also returned.
- bool canStencilAndDrawElement(GrTexture* target, const SkClipStack::Element*, GrPathRenderer**);
+ bool canStencilAndDrawElement(GrTexture* target, const SkClipStack::Element*,
+ GrPathRenderer::AutoClearPath* pr);
void mergeMask(GrTexture* dstMask,
GrTexture* srcMask,
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index bb0f4fa..ab20dc3 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -1148,16 +1148,18 @@
GrPathRendererChain::DrawType type =
useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
- GrPathRendererChain::kColor_DrawType;
+ GrPathRendererChain::kColor_DrawType;
const SkPath* pathPtr = &path;
SkTLazy<SkPath> tmpPath;
SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
// Try a 1st time without stroking the path and without allowing the SW renderer
- GrPathRenderer* pr = this->getPathRenderer(*pathPtr, *stroke, target, false, type);
+ GrPathRenderer::AutoClearPath acp(this->getPathRenderer(*pathPtr, *stroke,
+ target, false, type,
+ pathPtr->getFillType()));
- if (NULL == pr) {
+ if (NULL == acp.renderer()) {
if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, this->getMatrix(), NULL)) {
// It didn't work the 1st time, so try again with the stroked path
if (stroke->applyToPath(tmpPath.init(), *pathPtr)) {
@@ -1170,17 +1172,18 @@
}
// This time, allow SW renderer
- pr = this->getPathRenderer(*pathPtr, *stroke, target, true, type);
+ acp.set(this->getPathRenderer(*pathPtr, *stroke, target, true, type,
+ pathPtr->getFillType()));
}
- if (NULL == pr) {
+ if (NULL == acp.renderer()) {
#ifdef SK_DEBUG
GrPrintf("Unable to find path renderer compatible with path.\n");
#endif
return;
}
- pr->drawPath(*pathPtr, *stroke, target, useCoverageAA);
+ acp->drawPath(*stroke, target, useCoverageAA);
}
////////////////////////////////////////////////////////////////////////////////
@@ -1676,6 +1679,7 @@
const GrDrawTarget* target,
bool allowSW,
GrPathRendererChain::DrawType drawType,
+ SkPath::FillType fillType,
GrPathRendererChain::StencilSupport* stencilSupport) {
if (NULL == fPathRendererChain) {
@@ -1686,6 +1690,7 @@
stroke,
target,
drawType,
+ fillType,
stencilSupport);
if (NULL == pr && allowSW) {
@@ -1693,6 +1698,7 @@
fSoftwarePathRenderer = SkNEW_ARGS(GrSoftwarePathRenderer, (this));
}
pr = fSoftwarePathRenderer;
+ pr->setPath(path, fillType);
}
return pr;
diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp
index 1f20ac2..69da9d9 100644
--- a/src/gpu/GrDefaultPathRenderer.cpp
+++ b/src/gpu/GrDefaultPathRenderer.cpp
@@ -163,10 +163,9 @@
}
GrPathRenderer::StencilSupport GrDefaultPathRenderer::onGetStencilSupport(
- const SkPath& path,
const SkStrokeRec& stroke,
const GrDrawTarget*) const {
- if (single_pass_path(path, stroke)) {
+ if (single_pass_path(this->path(), stroke)) {
return GrPathRenderer::kNoRestriction_StencilSupport;
} else {
return GrPathRenderer::kStencilOnly_StencilSupport;
@@ -325,8 +324,7 @@
return true;
}
-bool GrDefaultPathRenderer::internalDrawPath(const SkPath& path,
- const SkStrokeRec& origStroke,
+bool GrDefaultPathRenderer::internalDrawPath(const SkStrokeRec& origStroke,
GrDrawTarget* target,
bool stencilOnly) {
@@ -346,13 +344,13 @@
}
SkScalar tol = SK_Scalar1;
- tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, path.getBounds());
+ tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, this->path().getBounds());
int vertexCnt;
int indexCnt;
GrPrimitiveType primType;
GrDrawTarget::AutoReleaseGeometry arg;
- if (!this->createGeom(path,
+ if (!this->createGeom(this->path(),
*stroke,
tol,
target,
@@ -386,7 +384,7 @@
lastPassIsBounds = false;
drawFace[0] = GrDrawState::kBoth_DrawFace;
} else {
- if (single_pass_path(path, *stroke)) {
+ if (single_pass_path(this->path(), *stroke)) {
passCount = 1;
if (stencilOnly) {
passes[0] = &gDirectToStencil;
@@ -396,7 +394,7 @@
drawFace[0] = GrDrawState::kBoth_DrawFace;
lastPassIsBounds = false;
} else {
- switch (path.getFillType()) {
+ switch (this->path().getFillType()) {
case SkPath::kInverseEvenOdd_FillType:
reverse = true;
// fallthrough
@@ -463,7 +461,7 @@
}
SkRect devBounds;
- GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
+ GetPathDevBounds(this->path(), drawState->getRenderTarget(), viewM, &devBounds);
for (int p = 0; p < passCount; ++p) {
drawState->setDrawFace(drawFace[p]);
@@ -490,7 +488,7 @@
avmr.setIdentity(drawState);
}
} else {
- bounds = path.getBounds();
+ bounds = this->path().getBounds();
}
GrDrawTarget::AutoGeometryAndStatePush agasp(target, GrDrawTarget::kPreserve_ASRInit);
target->drawSimpleRect(bounds, NULL);
@@ -509,8 +507,7 @@
return true;
}
-bool GrDefaultPathRenderer::canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrDefaultPathRenderer::canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const {
// this class can draw any path with any fill but doesn't do any anti-aliasing.
@@ -520,20 +517,15 @@
IsStrokeHairlineOrEquivalent(stroke, target->getDrawState().getViewMatrix(), NULL));
}
-bool GrDefaultPathRenderer::onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrDefaultPathRenderer::onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
- return this->internalDrawPath(path,
- stroke,
- target,
- false);
+ return this->internalDrawPath(stroke, target, false);
}
-void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
- const SkStrokeRec& stroke,
+void GrDefaultPathRenderer::onStencilPath(const SkStrokeRec& stroke,
GrDrawTarget* target) {
- SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
- SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
- this->internalDrawPath(path, stroke, target, true);
+ SkASSERT(SkPath::kInverseEvenOdd_FillType != this->path().getFillType());
+ SkASSERT(SkPath::kInverseWinding_FillType != this->path().getFillType());
+ this->internalDrawPath(stroke, target, true);
}
diff --git a/src/gpu/GrDefaultPathRenderer.h b/src/gpu/GrDefaultPathRenderer.h
index c60afcc..56d4370 100644
--- a/src/gpu/GrDefaultPathRenderer.h
+++ b/src/gpu/GrDefaultPathRenderer.h
@@ -19,28 +19,23 @@
public:
GrDefaultPathRenderer(bool separateStencilSupport, bool stencilWrapOpsSupport);
- virtual bool canDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool canDrawPath(const SkStrokeRec&,
const GrDrawTarget*,
bool antiAlias) const SK_OVERRIDE;
private:
- virtual StencilSupport onGetStencilSupport(const SkPath&,
- const SkStrokeRec&,
+ virtual StencilSupport onGetStencilSupport(const SkStrokeRec&,
const GrDrawTarget*) const SK_OVERRIDE;
- virtual bool onDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool onDrawPath(const SkStrokeRec&,
GrDrawTarget*,
bool antiAlias) SK_OVERRIDE;
- virtual void onStencilPath(const SkPath&,
- const SkStrokeRec&,
+ virtual void onStencilPath(const SkStrokeRec&,
GrDrawTarget*) SK_OVERRIDE;
- bool internalDrawPath(const SkPath&,
- const SkStrokeRec&,
+ bool internalDrawPath(const SkStrokeRec&,
GrDrawTarget*,
bool stencilOnly);
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index 88665c1..692cefc 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -74,70 +74,108 @@
GrPathRendererChain::kNoRestriction_StencilSupport;
/**
- * This function is to get the stencil support for a particular path. The path's fill must
+ * This function is to get the stencil support for the current path. The path's fill must
* not be an inverse type.
*
- * @param target target that the path will be rendered to
- * @param path the path that will be drawn
* @param stroke the stroke information (width, join, cap).
+ * @param target target that the path will be rendered to
*/
- StencilSupport getStencilSupport(const SkPath& path,
- const SkStrokeRec& stroke,
+ StencilSupport getStencilSupport(const SkStrokeRec& stroke,
const GrDrawTarget* target) const {
- SkASSERT(!path.isInverseFillType());
- return this->onGetStencilSupport(path, stroke, target);
+ SkASSERT(!fPath.isInverseFillType());
+ return this->onGetStencilSupport(stroke, target);
+ }
+
+ // Set the path and fill type the path renderer is to use.
+ // 'fillType' is included as a parameter b.c. we often want to draw
+ // inverse filled paths normally filled.
+ void setPath(const SkPath& path, SkPath::FillType fillType) {
+ SkASSERT(fPath.isEmpty());
+ fPath = path;
+ fPath.setFillType(fillType);
+ }
+
+ void resetPath() {
+ fPath.reset();
}
/**
- * Returns true if this path renderer is able to render the path. Returning false allows the
- * caller to fallback to another path renderer This function is called when searching for a path
- * renderer capable of rendering a path.
+ * Returns true if this path renderer is able to render the current path. Returning false
+ * allows the caller to fallback to another path renderer This function is called when
+ * searching for a path renderer capable of rendering a path.
*
- * @param path The path to draw
* @param stroke The stroke information (width, join, cap)
* @param target The target that the path will be rendered to
* @param antiAlias True if anti-aliasing is required.
*
* @return true if the path can be drawn by this object, false otherwise.
*/
- virtual bool canDrawPath(const SkPath& path,
- const SkStrokeRec& rec,
+ virtual bool canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const = 0;
/**
- * Draws the path into the draw target. If getStencilSupport() would return kNoRestriction then
- * the subclass must respect the stencil settings of the target's draw state.
+ * Draws the current path into the draw target. If getStencilSupport() would return
+ * kNoRestriction then the subclass must respect the stencil settings of the
+ * target's draw state.
*
- * @param path the path to draw.
* @param stroke the stroke information (width, join, cap)
* @param target target that the path will be rendered to
* @param antiAlias true if anti-aliasing is required.
*/
- bool drawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ bool drawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
- SkASSERT(!path.isEmpty());
- SkASSERT(this->canDrawPath(path, stroke, target, antiAlias));
+ SkASSERT(!fPath.isEmpty());
+ SkASSERT(this->canDrawPath(stroke, target, antiAlias));
SkASSERT(target->drawState()->getStencil().isDisabled() ||
- kNoRestriction_StencilSupport == this->getStencilSupport(path, stroke, target));
- return this->onDrawPath(path, stroke, target, antiAlias);
+ kNoRestriction_StencilSupport == this->getStencilSupport(stroke, target));
+ return this->onDrawPath(stroke, target, antiAlias);
}
/**
- * Draws the path to the stencil buffer. Assume the writable stencil bits are already
- * initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.
+ * Draws the current path to the stencil buffer. Assume the writable stencil bits are already
+ * initialized to zero. The pixels inside the path will have non-zero stencil values
+ * afterwards.
*
- * @param path the path to draw.
* @param stroke the stroke information (width, join, cap)
* @param target target that the path will be rendered to
*/
- void stencilPath(const SkPath& path, const SkStrokeRec& stroke, GrDrawTarget* target) {
- SkASSERT(!path.isEmpty());
- SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
- this->onStencilPath(path, stroke, target);
+ void stencilPath(const SkStrokeRec& stroke, GrDrawTarget* target) {
+ SkASSERT(!fPath.isEmpty());
+ SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(stroke, target));
+ this->onStencilPath(stroke, target);
}
+ class AutoClearPath : ::SkNoncopyable {
+ public:
+ AutoClearPath(GrPathRenderer* renderer) : fRenderer(renderer) {}
+ AutoClearPath() : fRenderer(NULL) {}
+ ~AutoClearPath() {
+ this->reset();
+ }
+
+ GrPathRenderer* renderer() {
+ return fRenderer;
+ }
+
+ void set(GrPathRenderer* renderer) {
+ this->reset();
+ fRenderer = renderer;
+ }
+
+ GrPathRenderer* operator->() { return fRenderer; }
+
+ private:
+ void reset() {
+ if (NULL != fRenderer) {
+ fRenderer->resetPath();
+ }
+ fRenderer = NULL;
+ }
+
+ GrPathRenderer* fRenderer;
+ };
+
// Helper for determining if we can treat a thin stroke as a hairline w/ coverage.
// If we can, we draw lots faster (raster device does this same test).
static bool IsStrokeHairlineOrEquivalent(const SkStrokeRec& stroke, const SkMatrix& matrix,
@@ -153,11 +191,14 @@
}
protected:
+ const SkPath& path() const {
+ return fPath;
+ }
+
/**
* Subclass overrides if it has any limitations of stenciling support.
*/
- virtual StencilSupport onGetStencilSupport(const SkPath&,
- const SkStrokeRec&,
+ virtual StencilSupport onGetStencilSupport(const SkStrokeRec&,
const GrDrawTarget*) const {
return kNoRestriction_StencilSupport;
}
@@ -165,8 +206,7 @@
/**
* Subclass implementation of drawPath()
*/
- virtual bool onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+ virtual bool onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) = 0;
@@ -174,7 +214,7 @@
* Subclass implementation of stencilPath(). Subclass must override iff it ever returns
* kStencilOnly in onGetStencilSupport().
*/
- virtual void onStencilPath(const SkPath& path, const SkStrokeRec& stroke, GrDrawTarget* target) {
+ virtual void onStencilPath(const SkStrokeRec& stroke, GrDrawTarget* target) {
GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
GrDrawState* drawState = target->drawState();
GR_STATIC_CONST_SAME_STENCIL(kIncrementStencil,
@@ -186,7 +226,7 @@
0xffff);
drawState->setStencil(kIncrementStencil);
drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
- this->drawPath(path, stroke, target, false);
+ this->drawPath(stroke, target, false);
}
// Helper for getting the device bounds of a path. Inverse filled paths will have bounds set
@@ -206,6 +246,7 @@
}
private:
+ SkPath fPath;
typedef SkRefCnt INHERITED;
};
diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp
index cac0475..8911288 100644
--- a/src/gpu/GrPathRendererChain.cpp
+++ b/src/gpu/GrPathRendererChain.cpp
@@ -35,6 +35,7 @@
const SkStrokeRec& stroke,
const GrDrawTarget* target,
DrawType drawType,
+ SkPath::FillType fillType,
StencilSupport* stencilSupport) {
if (!fInit) {
this->init();
@@ -56,12 +57,11 @@
minStencilSupport = GrPathRenderer::kNoSupport_StencilSupport;
}
-
for (int i = 0; i < fChain.count(); ++i) {
- if (fChain[i]->canDrawPath(path, stroke, target, antiAlias)) {
+ fChain[i]->setPath(path, fillType);
+ if (fChain[i]->canDrawPath(stroke, target, antiAlias)) {
if (GrPathRenderer::kNoSupport_StencilSupport != minStencilSupport) {
- GrPathRenderer::StencilSupport support = fChain[i]->getStencilSupport(path,
- stroke,
+ GrPathRenderer::StencilSupport support = fChain[i]->getStencilSupport(stroke,
target);
if (support < minStencilSupport) {
continue;
@@ -71,6 +71,7 @@
}
return fChain[i];
}
+ fChain[i]->resetPath();
}
return NULL;
}
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index d0936d6..61711c0 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -11,8 +11,7 @@
#include "GrSWMaskHelper.h"
////////////////////////////////////////////////////////////////////////////////
-bool GrSoftwarePathRenderer::canDrawPath(const SkPath&,
- const SkStrokeRec&,
+bool GrSoftwarePathRenderer::canDrawPath(const SkStrokeRec&,
const GrDrawTarget*,
bool antiAlias) const {
if (!antiAlias || NULL == fContext) {
@@ -29,7 +28,6 @@
}
GrPathRenderer::StencilSupport GrSoftwarePathRenderer::onGetStencilSupport(
- const SkPath&,
const SkStrokeRec&,
const GrDrawTarget*) const {
return GrPathRenderer::kNoSupport_StencilSupport;
@@ -113,8 +111,7 @@
////////////////////////////////////////////////////////////////////////////////
// return true on success; false on failure
-bool GrSoftwarePathRenderer::onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrSoftwarePathRenderer::onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
@@ -127,16 +124,16 @@
SkMatrix vm = drawState->getViewMatrix();
SkIRect devPathBounds, devClipBounds;
- if (!get_path_and_clip_bounds(target, path, vm,
+ if (!get_path_and_clip_bounds(target, this->path(), vm,
&devPathBounds, &devClipBounds)) {
- if (path.isInverseFillType()) {
+ if (this->path().isInverseFillType()) {
draw_around_inv_path(target, devClipBounds, devPathBounds);
}
return true;
}
SkAutoTUnref<GrTexture> texture(
- GrSWMaskHelper::DrawPathMaskToTexture(fContext, path, stroke,
+ GrSWMaskHelper::DrawPathMaskToTexture(fContext, this->path(), stroke,
devPathBounds,
antiAlias, &vm));
if (NULL == texture) {
@@ -145,7 +142,7 @@
GrSWMaskHelper::DrawToTargetWithPathMask(texture, target, devPathBounds);
- if (path.isInverseFillType()) {
+ if (this->path().isInverseFillType()) {
draw_around_inv_path(target, devClipBounds, devPathBounds);
}
diff --git a/src/gpu/GrSoftwarePathRenderer.h b/src/gpu/GrSoftwarePathRenderer.h
index f8c5620..6e8cec4 100644
--- a/src/gpu/GrSoftwarePathRenderer.h
+++ b/src/gpu/GrSoftwarePathRenderer.h
@@ -24,17 +24,14 @@
: fContext(context) {
}
- virtual bool canDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool canDrawPath(const SkStrokeRec&,
const GrDrawTarget*,
bool antiAlias) const SK_OVERRIDE;
protected:
- virtual StencilSupport onGetStencilSupport(const SkPath&,
- const SkStrokeRec&,
+ virtual StencilSupport onGetStencilSupport(const SkStrokeRec&,
const GrDrawTarget*) const SK_OVERRIDE;
- virtual bool onDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool onDrawPath(const SkStrokeRec&,
GrDrawTarget*,
bool antiAlias) SK_OVERRIDE;
diff --git a/src/gpu/GrStencilAndCoverPathRenderer.cpp b/src/gpu/GrStencilAndCoverPathRenderer.cpp
index 273c01b..ff287b7 100644
--- a/src/gpu/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/GrStencilAndCoverPathRenderer.cpp
@@ -34,8 +34,7 @@
fGpu->unref();
}
-bool GrStencilAndCoverPathRenderer::canDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrStencilAndCoverPathRenderer::canDrawPath(const SkStrokeRec& stroke,
const GrDrawTarget* target,
bool antiAlias) const {
return !stroke.isHairlineStyle() &&
@@ -45,22 +44,19 @@
}
GrPathRenderer::StencilSupport GrStencilAndCoverPathRenderer::onGetStencilSupport(
- const SkPath&,
const SkStrokeRec& ,
const GrDrawTarget*) const {
return GrPathRenderer::kStencilOnly_StencilSupport;
}
-void GrStencilAndCoverPathRenderer::onStencilPath(const SkPath& path,
- const SkStrokeRec& stroke,
+void GrStencilAndCoverPathRenderer::onStencilPath(const SkStrokeRec& stroke,
GrDrawTarget* target) {
- SkASSERT(!path.isInverseFillType());
- SkAutoTUnref<GrPath> p(fGpu->getContext()->createPath(path, stroke));
- target->stencilPath(p, path.getFillType());
+ SkASSERT(!this->path().isInverseFillType());
+ SkAutoTUnref<GrPath> p(fGpu->getContext()->createPath(this->path(), stroke));
+ target->stencilPath(p, this->path().getFillType());
}
-bool GrStencilAndCoverPathRenderer::onDrawPath(const SkPath& path,
- const SkStrokeRec& stroke,
+bool GrStencilAndCoverPathRenderer::onDrawPath(const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
SkASSERT(!antiAlias);
@@ -69,9 +65,9 @@
GrDrawState* drawState = target->drawState();
SkASSERT(drawState->getStencil().isDisabled());
- SkAutoTUnref<GrPath> p(fGpu->getContext()->createPath(path, stroke));
+ SkAutoTUnref<GrPath> p(fGpu->getContext()->createPath(this->path(), stroke));
- if (path.isInverseFillType()) {
+ if (this->path().isInverseFillType()) {
GR_STATIC_CONST_SAME_STENCIL(kInvertedStencilPass,
kZero_StencilOp,
kZero_StencilOp,
@@ -96,7 +92,7 @@
*drawState->stencil() = kStencilPass;
}
- target->drawPath(p, path.getFillType());
+ target->drawPath(p, this->path().getFillType());
target->drawState()->stencil()->setDisabled();
return true;
diff --git a/src/gpu/GrStencilAndCoverPathRenderer.h b/src/gpu/GrStencilAndCoverPathRenderer.h
index 9ebcec9..4cd6581 100644
--- a/src/gpu/GrStencilAndCoverPathRenderer.h
+++ b/src/gpu/GrStencilAndCoverPathRenderer.h
@@ -25,23 +25,19 @@
virtual ~GrStencilAndCoverPathRenderer();
- virtual bool canDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool canDrawPath(const SkStrokeRec&,
const GrDrawTarget*,
bool antiAlias) const SK_OVERRIDE;
protected:
- virtual StencilSupport onGetStencilSupport(const SkPath&,
- const SkStrokeRec&,
+ virtual StencilSupport onGetStencilSupport(const SkStrokeRec&,
const GrDrawTarget*) const SK_OVERRIDE;
- virtual bool onDrawPath(const SkPath&,
- const SkStrokeRec&,
+ virtual bool onDrawPath(const SkStrokeRec&,
GrDrawTarget*,
bool antiAlias) SK_OVERRIDE;
- virtual void onStencilPath(const SkPath&,
- const SkStrokeRec&,
+ virtual void onStencilPath(const SkStrokeRec&,
GrDrawTarget*) SK_OVERRIDE;
private: