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

Convert a few path renderer class batches from Batch to Op.

Browse Source 
This also removes the "batch tracker" structs from the Op classes. Some tracker fields weren't used and some values were being stored per-path even though onCombineIfPossible assured they were the same. This also backs away from the generic "geometry" naming of batched items in favor of "path" or "shape".

Change-Id: Iabaa0cedf2bdf09ad135fc382ddfba8e5e94e4be
Reviewed-on: https://skia-review.googlesource.com/6152
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
This commit is contained in:
Brian Salomon 2016-12-15 15:25:22 -05:00 committed by Skia Commit-Bot
parent ada12ab055
commit d0a0a652b4
5 changed files with 162 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/gpu/GrBatchTest.cpp
View File

@ -11,11 +11,11 @@
#ifdef GR_TEST_UTILS
DRAW_BATCH_TEST_EXTERN(AAConvexPathBatch);
DRAW_BATCH_TEST_EXTERN(AADistanceFieldPathBatch);
DRAW_BATCH_TEST_EXTERN(AAConvexPathOp);
DRAW_BATCH_TEST_EXTERN(AADistanceFieldPathOp);
DRAW_BATCH_TEST_EXTERN(AAFillRectOp);
DRAW_BATCH_TEST_EXTERN(AAFillRectOpLocalMatrix);
DRAW_BATCH_TEST_EXTERN(AAHairlineBatch);
DRAW_BATCH_TEST_EXTERN(AAHairlineOp);
DRAW_BATCH_TEST_EXTERN(AAStrokeRectOp);
DRAW_BATCH_TEST_EXTERN(AnalyticRectOp);
DRAW_BATCH_TEST_EXTERN(DashBatch);
@ -31,11 +31,11 @@ DRAW_BATCH_TEST_EXTERN(TextBlobBatch);
DRAW_BATCH_TEST_EXTERN(VerticesOp);
static BatchTestFunc gTestBatches[] = {
DRAW_BATCH_TEST_ENTRY(AAConvexPathBatch),
DRAW_BATCH_TEST_ENTRY(AADistanceFieldPathBatch),
DRAW_BATCH_TEST_ENTRY(AAConvexPathOp),
DRAW_BATCH_TEST_ENTRY(AADistanceFieldPathOp),
DRAW_BATCH_TEST_ENTRY(AAFillRectOp),
DRAW_BATCH_TEST_ENTRY(AAFillRectOpLocalMatrix),
DRAW_BATCH_TEST_ENTRY(AAHairlineBatch),
DRAW_BATCH_TEST_ENTRY(AAHairlineOp),
DRAW_BATCH_TEST_ENTRY(AAStrokeRectOp),
DRAW_BATCH_TEST_ENTRY(AnalyticRectOp),
DRAW_BATCH_TEST_ENTRY(DashBatch),

96
src/gpu/batches/GrAAConvexPathRenderer.cpp
View File

@ -732,23 +732,18 @@ static sk_sp<GrGeometryProcessor> create_fill_gp(bool tweakAlphaForCoverage,
return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
}
class AAConvexPathBatch final : public GrMeshDrawOp {
class AAConvexPathOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
AAConvexPathBatch(GrColor color, const SkMatrix& viewMatrix, const SkPath& path)
: INHERITED(ClassID()) {
fGeoData.emplace_back(Geometry{color, viewMatrix, path});
this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes,
IsZeroArea::kNo);
static sk_sp<GrDrawOp> Make(GrColor color, const SkMatrix& viewMatrix, const SkPath& path) {
return sk_sp<GrDrawOp>(new AAConvexPathOp(color, viewMatrix, path));
}
const char* name() const override { return "AAConvexBatch"; }
const char* name() const override { return "AAConvexPathOp"; }
SkString dumpInfo() const override {
SkString string;
for (const auto& geo : fGeoData) {
string.appendf("Color: 0x%08x\n", geo.fColor);
}
string.appendf("Color: 0x%08x, Count: %d\n", fColor, fPaths.count());
string.append(DumpPipelineInfo(*this->pipeline()));
string.append(INHERITED::dumpInfo());
return string;
@ -757,26 +752,28 @@ public:
void computePipelineOptimizations(GrInitInvariantOutput* color,
GrInitInvariantOutput* coverage,
GrBatchToXPOverrides* overrides) const override {
// When this is called on a batch, there is only one geometry bundle
color->setKnownFourComponents(fGeoData[0].fColor);
color->setKnownFourComponents(fColor);
coverage->setUnknownSingleComponent();
}
private:
AAConvexPathOp(GrColor color, const SkMatrix& viewMatrix, const SkPath& path)
: INHERITED(ClassID()), fColor(color) {
fPaths.emplace_back(PathData{viewMatrix, path});
this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
}
void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
// Handle any color overrides
if (!overrides.readsColor()) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fColor = GrColor_ILLEGAL;
}
overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
overrides.getOverrideColorIfSet(&fColor);
// setup batch properties
fBatch.fColorIgnored = !overrides.readsColor();
fBatch.fColor = fGeoData[0].fColor;
fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
fBatch.fCoverageIgnored = !overrides.readsCoverage();
fBatch.fLinesOnly = SkPath::kLine_SegmentMask == fGeoData[0].fPath.getSegmentMasks();
fBatch.fCanTweakAlphaForCoverage = overrides.canTweakAlphaForCoverage();
fUsesLocalCoords = overrides.readsLocalCoords();
fCoverageIgnored = !overrides.readsCoverage();
fLinesOnly = SkPath::kLine_SegmentMask == fPaths[0].fPath.getSegmentMasks();
fCanTweakAlphaForCoverage = overrides.canTweakAlphaForCoverage();
}
void prepareLinesOnlyDraws(Target* target) const {
@ -800,12 +797,12 @@ private:
GrAAConvexTessellator tess;
int instanceCount = fGeoData.count();
int instanceCount = fPaths.count();
for (int i = 0; i < instanceCount; i++) {
tess.rewind();
const Geometry& args = fGeoData[i];
const PathData& args = fPaths[i];
if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
continue;
@ -830,7 +827,7 @@ private:
return;
}
extract_verts(tess, verts, vertexStride, args.fColor, idxs, canTweakAlphaForCoverage);
extract_verts(tess, verts, vertexStride, fColor, idxs, canTweakAlphaForCoverage);
GrMesh mesh;
mesh.initIndexed(kTriangles_GrPrimitiveType,
@ -849,7 +846,7 @@ private:
}
#endif
int instanceCount = fGeoData.count();
int instanceCount = fPaths.count();
SkMatrix invert;
if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
@ -863,7 +860,7 @@ private:
// TODO generate all segments for all paths and use one vertex buffer
for (int i = 0; i < instanceCount; i++) {
const Geometry& args = fGeoData[i];
const PathData& args = fPaths[i];
// We use the fact that SkPath::transform path does subdivision based on
// perspective. Otherwise, we apply the view matrix when copying to the
@ -933,7 +930,7 @@ private:
}
bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AAConvexPathBatch* that = t->cast<AAConvexPathBatch>();
AAConvexPathOp* that = t->cast<AAConvexPathOp>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
that->bounds(), caps)) {
return false;
@ -952,41 +949,36 @@ private:
return false;
}
// In the event of two batches, one who can tweak, one who cannot, we just fall back to
// not tweaking
// In the event of two ops, one who can tweak, one who cannot, we just fall back to not
// tweaking
if (this->canTweakAlphaForCoverage() != that->canTweakAlphaForCoverage()) {
fBatch.fCanTweakAlphaForCoverage = false;
fCanTweakAlphaForCoverage = false;
}
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
this->joinBounds(*that);
return true;
}
GrColor color() const { return fBatch.fColor; }
bool linesOnly() const { return fBatch.fLinesOnly; }
bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
GrColor color() const { return fColor; }
bool linesOnly() const { return fLinesOnly; }
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool canTweakAlphaForCoverage() const { return fCanTweakAlphaForCoverage; }
const SkMatrix& viewMatrix() const { return fPaths[0].fViewMatrix; }
bool coverageIgnored() const { return fCoverageIgnored; }
struct BatchTracker {
GrColor fColor;
bool fUsesLocalCoords;
bool fColorIgnored;
bool fCoverageIgnored;
bool fLinesOnly;
bool fCanTweakAlphaForCoverage;
};
GrColor fColor;
bool fUsesLocalCoords;
bool fCoverageIgnored;
bool fLinesOnly;
bool fCanTweakAlphaForCoverage;
struct Geometry {
GrColor fColor;
struct PathData {
SkMatrix fViewMatrix;
SkPath fPath;
};
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
SkSTArray<1, PathData, true> fPaths;
typedef GrMeshDrawOp INHERITED;
};
@ -1000,7 +992,7 @@ bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
SkPath path;
args.fShape->asPath(&path);
sk_sp<GrDrawOp> op(new AAConvexPathBatch(args.fPaint->getColor(), *args.fViewMatrix, path));
sk_sp<GrDrawOp> op = AAConvexPathOp::Make(args.fPaint->getColor(), *args.fViewMatrix, path);
GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
@ -1015,12 +1007,12 @@ bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
#ifdef GR_TEST_UTILS
DRAW_BATCH_TEST_DEFINE(AAConvexPathBatch) {
DRAW_BATCH_TEST_DEFINE(AAConvexPathOp) {
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
SkPath path = GrTest::TestPathConvex(random);
return new AAConvexPathBatch(color, viewMatrix, path);
return AAConvexPathOp::Make(color, viewMatrix, path).release();
}
#endif

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

@ -118,38 +118,26 @@ bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c
// padding around path bounds to allow for antialiased pixels
static const SkScalar kAntiAliasPad = 1.0f;
class AADistanceFieldPathBatch final : public GrMeshDrawOp {
class AADistanceFieldPathOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
typedef GrAADistanceFieldPathRenderer::ShapeData ShapeData;
typedef SkTDynamicHash<ShapeData, ShapeData::Key> ShapeCache;
typedef GrAADistanceFieldPathRenderer::ShapeDataList ShapeDataList;
using ShapeData = GrAADistanceFieldPathRenderer::ShapeData;
using ShapeCache = SkTDynamicHash<ShapeData, ShapeData::Key>;
using ShapeDataList = GrAADistanceFieldPathRenderer::ShapeDataList;
AADistanceFieldPathBatch(GrColor color,
const GrShape& shape,
const SkMatrix& viewMatrix,
GrBatchAtlas* atlas,
ShapeCache* shapeCache, ShapeDataList* shapeList,
bool gammaCorrect)
: INHERITED(ClassID()) {
SkASSERT(shape.hasUnstyledKey());
fBatch.fViewMatrix = viewMatrix;
fGeoData.emplace_back(Geometry{color, shape});
fAtlas = atlas;
fShapeCache = shapeCache;
fShapeList = shapeList;
fGammaCorrect = gammaCorrect;
// Compute bounds
this->setTransformedBounds(shape.bounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
static sk_sp<GrDrawOp> Make(GrColor color, const GrShape& shape, const SkMatrix& viewMatrix,
GrBatchAtlas* atlas, ShapeCache* shapeCache,
ShapeDataList* shapeList, bool gammaCorrect) {
return sk_sp<GrDrawOp>(new AADistanceFieldPathOp(color, shape, viewMatrix, atlas,
shapeCache, shapeList, gammaCorrect));
}
const char* name() const override { return "AADistanceFieldPathBatch"; }
const char* name() const override { return "AADistanceFieldPathOp"; }
SkString dumpInfo() const override {
SkString string;
for (const auto& geo : fGeoData) {
for (const auto& geo : fShapes) {
string.appendf("Color: 0x%08x\n", geo.fColor);
}
string.append(DumpPipelineInfo(*this->pipeline()));
@ -160,22 +148,38 @@ public:
void computePipelineOptimizations(GrInitInvariantOutput* color,
GrInitInvariantOutput* coverage,
GrBatchToXPOverrides* overrides) const override {
color->setKnownFourComponents(fGeoData[0].fColor);
color->setKnownFourComponents(fShapes[0].fColor);
coverage->setUnknownSingleComponent();
}
private:
AADistanceFieldPathOp(GrColor color, const GrShape& shape, const SkMatrix& viewMatrix,
GrBatchAtlas* atlas, ShapeCache* shapeCache, ShapeDataList* shapeList,
bool gammaCorrect)
: INHERITED(ClassID()) {
SkASSERT(shape.hasUnstyledKey());
fViewMatrix = viewMatrix;
fShapes.emplace_back(Entry{color, shape});
fAtlas = atlas;
fShapeCache = shapeCache;
fShapeList = shapeList;
fGammaCorrect = gammaCorrect;
// Compute bounds
this->setTransformedBounds(shape.bounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
}
void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
// Handle any color overrides
if (!overrides.readsColor()) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fShapes[0].fColor = GrColor_ILLEGAL;
}
overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
overrides.getOverrideColorIfSet(&fShapes[0].fColor);
// setup batch properties
fBatch.fColorIgnored = !overrides.readsColor();
fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
fBatch.fCoverageIgnored = !overrides.readsCoverage();
fColorIgnored = !overrides.readsColor();
fUsesLocalCoords = overrides.readsLocalCoords();
fCoverageIgnored = !overrides.readsCoverage();
}
struct FlushInfo {
@ -187,7 +191,7 @@ private:
};
void onPrepareDraws(Target* target) const override {
int instanceCount = fGeoData.count();
int instanceCount = fShapes.count();
SkMatrix invert;
if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
@ -234,7 +238,7 @@ private:
// Pointer to the next set of vertices to write.
intptr_t offset = reinterpret_cast<intptr_t>(vertices);
for (int i = 0; i < instanceCount; i++) {
const Geometry& args = fGeoData[i];
const Entry& args = fShapes[i];
// get mip level
SkScalar maxScale = this->viewMatrix().getMaxScale();
@ -463,12 +467,12 @@ private:
}
}
GrColor color() const { return fGeoData[0].fColor; }
const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
GrColor color() const { return fShapes[0].fColor; }
const SkMatrix& viewMatrix() const { return fViewMatrix; }
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
AADistanceFieldPathOp* that = t->cast<AADistanceFieldPathOp>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
that->bounds(), caps)) {
return false;
@ -479,25 +483,22 @@ private:
return false;
}
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
fShapes.push_back_n(that->fShapes.count(), that->fShapes.begin());
this->joinBounds(*that);
return true;
}
struct BatchTracker {
SkMatrix fViewMatrix;
bool fUsesLocalCoords;
bool fColorIgnored;
bool fCoverageIgnored;
};
SkMatrix fViewMatrix;
bool fUsesLocalCoords;
bool fColorIgnored;
bool fCoverageIgnored;
struct Geometry {
struct Entry {
GrColor fColor;
GrShape fShape;
};
BatchTracker fBatch;
SkSTArray<1, Geometry> fGeoData;
SkSTArray<1, Entry> fShapes;
GrBatchAtlas* fAtlas;
ShapeCache* fShapeCache;
ShapeDataList* fShapeList;
@ -524,9 +525,9 @@ bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
}
}
sk_sp<GrDrawOp> op(new AADistanceFieldPathBatch(args.fPaint->getColor(), *args.fShape,
*args.fViewMatrix, fAtlas.get(), &fShapeCache,
&fShapeList, args.fGammaCorrect));
sk_sp<GrDrawOp> op = AADistanceFieldPathOp::Make(args.fPaint->getColor(), *args.fShape,
*args.fViewMatrix, fAtlas.get(), &fShapeCache,
&fShapeList, args.fGammaCorrect);
GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
@ -581,7 +582,7 @@ struct PathTestStruct {
ShapeDataList fShapeList;
};
DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathOp) {
static PathTestStruct gTestStruct;
if (context->uniqueID() != gTestStruct.fContextID) {
@ -602,13 +603,14 @@ DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
// This path renderer only allows fill styles.
GrShape shape(GrTest::TestPath(random), GrStyle::SimpleFill());
return new AADistanceFieldPathBatch(color,
shape,
viewMatrix,
gTestStruct.fAtlas.get(),
&gTestStruct.fShapeCache,
&gTestStruct.fShapeList,
gammaCorrect);
return AADistanceFieldPathOp::Make(color,
shape,
viewMatrix,
gTestStruct.fAtlas.get(),
&gTestStruct.fShapeCache,
&gTestStruct.fShapeList,
gammaCorrect)
.release();
}
#endif

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

@ -95,7 +95,7 @@ private:
typedef GrPathRenderer INHERITED;
friend class AADistanceFieldPathBatch;
friend class AADistanceFieldPathOp;
friend struct PathTestStruct;
};

120
src/gpu/batches/GrAAHairLinePathRenderer.cpp
View File

@ -675,29 +675,31 @@ bool check_bounds(const SkMatrix& viewMatrix, const SkRect& devBounds, void* ver
return true;
}
class AAHairlineBatch final : public GrMeshDrawOp {
class AAHairlineOp final : public GrMeshDrawOp {
public:
DEFINE_OP_CLASS_ID
AAHairlineBatch(GrColor color,
uint8_t coverage,
const SkMatrix& viewMatrix,
const SkPath& path,
SkIRect devClipBounds) : INHERITED(ClassID()) {
fGeoData.emplace_back(Geometry{color, coverage, viewMatrix, path, devClipBounds});
static sk_sp<GrDrawOp> Make(GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
const GrStyle& style,
const SkIRect& devClipBounds) {
SkScalar hairlineCoverage;
uint8_t newCoverage = 0xff;
if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
}
this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes,
IsZeroArea::kYes);
return sk_sp<GrDrawOp>(
new AAHairlineOp(color, newCoverage, viewMatrix, path, devClipBounds));
}
const char* name() const override { return "AAHairlineBatch"; }
const char* name() const override { return "AAHairlineOp"; }
SkString dumpInfo() const override {
SkString string;
for (const auto& geo : fGeoData) {
string.appendf("Color: 0x%08x Coverage: 0x%02x\n", geo.fColor, geo.fCoverage);
}
string.append(DumpPipelineInfo(*this->pipeline()));
string.appendf("Color: 0x%08x Coverage: 0x%02x, Count: %d\n", fColor, fCoverage,
fPaths.count());
string.append(INHERITED::dumpInfo());
return string;
}
@ -705,25 +707,31 @@ public:
void computePipelineOptimizations(GrInitInvariantOutput* color,
GrInitInvariantOutput* coverage,
GrBatchToXPOverrides* overrides) const override {
// When this is called on a batch, there is only one geometry bundle
color->setKnownFourComponents(fGeoData[0].fColor);
color->setKnownFourComponents(fColor);
coverage->setUnknownSingleComponent();
}
private:
AAHairlineOp(GrColor color,
uint8_t coverage,
const SkMatrix& viewMatrix,
const SkPath& path,
SkIRect devClipBounds)
: INHERITED(ClassID()), fColor(color), fCoverage(coverage) {
fPaths.emplace_back(PathData{viewMatrix, path, devClipBounds});
this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes,
IsZeroArea::kYes);
}
void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
// Handle any color overrides
if (!overrides.readsColor()) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fColor = GrColor_ILLEGAL;
}
overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
overrides.getOverrideColorIfSet(&fColor);
// setup batch properties
fBatch.fColorIgnored = !overrides.readsColor();
fBatch.fColor = fGeoData[0].fColor;
fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
fBatch.fCoverageIgnored = !overrides.readsCoverage();
fBatch.fCoverage = fGeoData[0].fCoverage;
fUsesLocalCoords = overrides.readsLocalCoords();
}
void onPrepareDraws(Target*) const override;
@ -733,7 +741,7 @@ private:
typedef SkTArray<float, true> FloatArray;
bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AAHairlineBatch* that = t->cast<AAHairlineBatch>();
AAHairlineOp* that = t->cast<AAHairlineOp>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
that->bounds(), caps)) {
@ -766,42 +774,32 @@ private:
return false;
}
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
this->joinBounds(*that);
return true;
}
GrColor color() const { return fBatch.fColor; }
uint8_t coverage() const { return fBatch.fCoverage; }
bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
GrColor color() const { return fColor; }
uint8_t coverage() const { return fCoverage; }
bool usesLocalCoords() const { return fUsesLocalCoords; }
const SkMatrix& viewMatrix() const { return fPaths[0].fViewMatrix; }
struct Geometry {
GrColor fColor;
uint8_t fCoverage;
struct PathData {
SkMatrix fViewMatrix;
SkPath fPath;
SkIRect fDevClipBounds;
};
struct BatchTracker {
GrColor fColor;
uint8_t fCoverage;
SkRect fDevBounds;
bool fUsesLocalCoords;
bool fColorIgnored;
bool fCoverageIgnored;
};
GrColor fColor;
uint8_t fCoverage;
bool fUsesLocalCoords;
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
SkSTArray<1, PathData, true> fPaths;
typedef GrMeshDrawOp INHERITED;
};
void AAHairlineBatch::onPrepareDraws(Target* target) const {
void AAHairlineOp::onPrepareDraws(Target* target) const {
// Setup the viewmatrix and localmatrix for the GrGeometryProcessor.
SkMatrix invert;
if (!this->viewMatrix().invert(&invert)) {
@ -829,9 +827,9 @@ void AAHairlineBatch::onPrepareDraws(Target* target) const {
FloatArray cWeights;
int quadCount = 0;
int instanceCount = fGeoData.count();
int instanceCount = fPaths.count();
for (int i = 0; i < instanceCount; i++) {
const Geometry& args = fGeoData[i];
const PathData& args = fPaths[i];
quadCount += gather_lines_and_quads(args.fPath, args.fViewMatrix, args.fDevClipBounds,
&lines, &quads, &conics, &qSubdivs, &cWeights);
}
@ -951,20 +949,6 @@ void AAHairlineBatch::onPrepareDraws(Target* target) const {
}
}
static GrDrawOp* create_hairline_batch(GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
const GrStyle& style,
const SkIRect& devClipBounds) {
SkScalar hairlineCoverage;
uint8_t newCoverage = 0xff;
if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
}
return new AAHairlineBatch(color, newCoverage, viewMatrix, path, devClipBounds);
}
bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrAAHairlinePathRenderer::onDrawPath");
@ -974,16 +958,13 @@ bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
args.fClip->getConservativeBounds(args.fRenderTargetContext->width(),
args.fRenderTargetContext->height(),
&devClipBounds);
SkPath path;
args.fShape->asPath(&path);
sk_sp<GrDrawOp> op(create_hairline_batch(args.fPaint->getColor(), *args.fViewMatrix, path,
args.fShape->style(), devClipBounds));
sk_sp<GrDrawOp> op = AAHairlineOp::Make(args.fPaint->getColor(), *args.fViewMatrix, path,
args.fShape->style(), devClipBounds);
GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
return true;
}
@ -991,13 +972,14 @@ bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
#ifdef GR_TEST_UTILS
DRAW_BATCH_TEST_DEFINE(AAHairlineBatch) {
DRAW_BATCH_TEST_DEFINE(AAHairlineOp) {
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrix(random);
SkPath path = GrTest::TestPath(random);
SkIRect devClipBounds;
devClipBounds.setEmpty();
return create_hairline_batch(color, viewMatrix, path, GrStyle::SimpleHairline(), devClipBounds);
return AAHairlineOp::Make(color, viewMatrix, path, GrStyle::SimpleHairline(), devClipBounds)
.release();
}
#endif