AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add stroking support to distance field path renderer

Browse Source 
Also slightly increases sizes of paths accepted for distance field
caching.

Review URL: https://codereview.chromium.org/1460873002
This commit is contained in:
jvanverth 2015-11-19 12:47:09 -08:00 committed by Commit bot
parent e9d2052e49
commit 5ce76efd1c
3 changed files with 60 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/gpu/GrPathRenderer.h
View File

@ -115,6 +115,7 @@ public:
* fTarget The target that the path will be rendered to
* fResourceProvider The resource provider for creating gpu resources to render the path
* fPipelineBuilder The pipelineBuilder
* fColor Color to render with
* fViewMatrix The viewMatrix
* fPath the path to draw.
* fStroke the stroke information (width, join, cap)

76
src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
View File

@ -38,7 +38,7 @@ static int g_NumFreedPaths = 0;
// mip levels
static const int kSmallMIP = 32;
static const int kMediumMIP = 72;
static const int kMediumMIP = 73;
static const int kLargeMIP = 162;
// Callback to clear out internal path cache when eviction occurs
@ -84,10 +84,9 @@ GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() {
bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
// TODO: Support inverse fill
// TODO: Support strokes
if (!args.fShaderCaps->shaderDerivativeSupport() || !args.fAntiAlias ||
args.fPath->isInverseFillType() || args.fPath->isVolatile() ||
!args.fStroke->isFillStyle()) {
SkStrokeRec::kHairline_Style == args.fStroke->getStyle() ||
args.fPath->isInverseFillType() || args.fPath->isVolatile()) {
return false;
}
@ -96,12 +95,22 @@ bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c
return false;
}
// only support paths smaller than 64x64, scaled to less than 256x256
// only support paths with bounds within kMediumMIP by kMediumMIP,
// scaled to have bounds within 2.0f*kLargeMIP by 2.0f*kLargeMIP
// the goal is to accelerate rendering of lots of small paths that may be scaling
SkScalar maxScale = args.fViewMatrix->getMaxScale();
const SkRect& bounds = args.fPath->getBounds();
SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
return maxDim < 64.f && maxDim * maxScale < 256.f;
// Approximate stroked size by adding the maximum of the stroke width or 2x the miter limit
if (!args.fStroke->isFillStyle()) {
SkScalar extraWidth = args.fStroke->getWidth();
if (SkPaint::kMiter_Join == args.fStroke->getJoin()) {
extraWidth = SkTMax(extraWidth, 2.0f*args.fStroke->getMiter());
}
maxDim += extraWidth;
}
return maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP;
}
////////////////////////////////////////////////////////////////////////////////
@ -120,6 +129,9 @@ public:
struct Geometry {
Geometry(const SkStrokeRec& stroke) : fStroke(stroke) {}
SkPath fPath;
// The unique ID of the path involved in this draw. This may be different than the ID
// in fPath since that path may have resulted from a SkStrokeRec::applyToPath call.
uint32_t fGenID;
SkStrokeRec fStroke;
bool fAntiAlias;
PathData* fPathData;
@ -225,8 +237,7 @@ private:
}
// check to see if path is cached
// TODO: handle stroked vs. filled version of same path
PathData::Key key = { args.fPath.getGenerationID(), desiredDimension };
PathData::Key key(args.fGenID, desiredDimension, args.fStroke);
args.fPathData = fPathCache->find(key);
if (nullptr == args.fPathData || !atlas->hasID(args.fPathData->fID)) {
// Remove the stale cache entry
@ -244,6 +255,7 @@ private:
atlas,
args.fPathData,
args.fPath,
args.fGenID,
args.fStroke,
args.fAntiAlias,
desiredDimension,
@ -301,8 +313,9 @@ private:
GrBatchAtlas* atlas,
PathData* pathData,
const SkPath& path,
const SkStrokeRec&
stroke, bool antiAlias,
uint32_t genID,
const SkStrokeRec& stroke,
bool antiAlias,
uint32_t dimension,
SkScalar scale) {
const SkRect& bounds = path.getBounds();
@ -333,41 +346,25 @@ private:
drawMatrix.postTranslate(kAntiAliasPad, kAntiAliasPad);
// setup bitmap backing
// Now translate so the bound's UL corner is at the origin
drawMatrix.postTranslate(-devPathBounds.fLeft * SK_Scalar1,
-devPathBounds.fTop * SK_Scalar1);
SkIRect pathBounds = SkIRect::MakeWH(devPathBounds.width(),
devPathBounds.height());
SkASSERT(devPathBounds.fLeft == 0);
SkASSERT(devPathBounds.fTop == 0);
SkAutoPixmapStorage dst;
if (!dst.tryAlloc(SkImageInfo::MakeA8(pathBounds.width(),
pathBounds.height()))) {
if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(),
devPathBounds.height()))) {
return false;
}
sk_bzero(dst.writable_addr(), dst.getSafeSize());
// rasterize path
SkPaint paint;
if (stroke.isHairlineStyle()) {
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SK_Scalar1);
} else {
if (stroke.isFillStyle()) {
paint.setStyle(SkPaint::kFill_Style);
} else {
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeJoin(stroke.getJoin());
paint.setStrokeCap(stroke.getCap());
paint.setStrokeWidth(stroke.getWidth());
}
}
paint.setStyle(SkPaint::kFill_Style);
paint.setAntiAlias(antiAlias);
SkDraw draw;
sk_bzero(&draw, sizeof(draw));
SkRasterClip rasterClip;
rasterClip.setRect(pathBounds);
rasterClip.setRect(devPathBounds);
draw.fRC = &rasterClip;
draw.fClip = &rasterClip.bwRgn();
draw.fMatrix = &drawMatrix;
@ -403,8 +400,7 @@ private:
}
// add to cache
pathData->fKey.fGenID = path.getGenerationID();
pathData->fKey.fDimension = dimension;
pathData->fKey = PathData::Key(genID, dimension, stroke);
pathData->fScale = scale;
pathData->fID = id;
// change the scaled rect to match the size of the inset distance field
@ -543,9 +539,17 @@ bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
}
AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
geometry.fPath = *args.fPath;
if (SkStrokeRec::kFill_Style == args.fStroke->getStyle()) {
geometry.fPath = *args.fPath;
} else {
args.fStroke->applyToPath(&geometry.fPath, *args.fPath);
}
geometry.fAntiAlias = args.fAntiAlias;
// Note: this is the generation ID of the _original_ path. When a new path is
// generated due to stroking it is important that the original path's id is used
// for caching.
geometry.fGenID = args.fPath->getGenerationID();
SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
*args.fViewMatrix, fAtlas,
&fPathCache, &fPathList));

23
src/gpu/batches/GrAADistanceFieldPathRenderer.h
View File

@ -33,13 +33,28 @@ private:
bool onDrawPath(const DrawPathArgs&) override;
struct PathData {
struct Key {
class Key {
public:
// default ctor needed for new of uninitialized PathData
// since fStroke has no default ctor
Key() : fStroke(SkStrokeRec::kFill_InitStyle) {}
Key(uint32_t genID, uint32_t dim, const SkStrokeRec& stroke)
: fGenID(genID)
, fDimension(dim)
, fStroke(stroke) {
}
bool operator==(const Key& other) const {
return other.fGenID == fGenID && other.fDimension == fDimension &&
fStroke.hasEqualEffect(other.fStroke);
}
private:
uint32_t fGenID;
// rendered size for stored path (32x32 max, 64x64 max, 128x128 max)
uint32_t fDimension;
bool operator==(const Key& other) const {
return other.fGenID == fGenID && other.fDimension == fDimension;
}
// stroking information
SkStrokeRec fStroke;
};
Key fKey;
SkScalar fScale;