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

Even more hiding of Geometry structs in GrBatch subclasses.

Browse Source 
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2110853004

Review-Url: https://codereview.chromium.org/2110853004
This commit is contained in:
bsalomon 2016-06-30 07:19:27 -07:00 committed by Commit bot
parent 47df89ebfd
commit 0432dd6ee6
5 changed files with 89 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/gpu/GrDrawContext.cpp
View File

@ -585,10 +585,8 @@ void GrDrawContext::drawAtlas(const GrClip& clip,
AutoCheckFlush acf(fDrawingManager);
GrDrawAtlasBatch::Geometry geometry;
geometry.fColor = paint.getColor();
SkAutoTUnref<GrDrawBatch> batch(GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount,
xform, texRect, colors));
SkAutoTUnref<GrDrawBatch> batch(new GrDrawAtlasBatch(paint.getColor(), viewMatrix, spriteCount,
xform, texRect, colors));
GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);

88
src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
View File

@ -122,17 +122,26 @@ class AAFlatteningConvexPathBatch : public GrVertexBatch {
public:
DEFINE_BATCH_CLASS_ID
struct Geometry {
GrColor fColor;
SkMatrix fViewMatrix;
SkPath fPath;
SkScalar fStrokeWidth;
SkPaint::Join fJoin;
SkScalar fMiterLimit;
};
AAFlatteningConvexPathBatch(GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
SkScalar strokeWidth,
SkPaint::Join join,
SkScalar miterLimit) : INHERITED(ClassID()) {
fGeoData.emplace_back(Geometry{color, viewMatrix, path, strokeWidth, join, miterLimit});
static GrDrawBatch* Create(const Geometry& geometry) {
return new AAFlatteningConvexPathBatch(geometry);
// compute bounds
fBounds = path.getBounds();
SkScalar w = strokeWidth;
if (w > 0) {
w /= 2;
// If the half stroke width is < 1 then we effectively fallback to bevel joins.
if (SkPaint::kMiter_Join == join && w > 1.f) {
w *= miterLimit;
}
fBounds.outset(w, w);
}
viewMatrix.mapRect(&fBounds);
}
const char* name() const override { return "AAConvexBatch"; }
@ -256,25 +265,6 @@ private:
sk_free(indices);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
AAFlatteningConvexPathBatch(const Geometry& geometry) : INHERITED(ClassID()) {
fGeoData.push_back(geometry);
// compute bounds
fBounds = geometry.fPath.getBounds();
SkScalar w = geometry.fStrokeWidth;
if (w > 0) {
w /= 2;
// If the miter limit is < 1 then we effectively fallback to bevel joins.
if (SkPaint::kMiter_Join == geometry.fJoin && w > 1.f) {
w *= geometry.fMiterLimit;
}
fBounds.outset(w, w);
}
geometry.fViewMatrix.mapRect(&fBounds);
}
bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
AAFlatteningConvexPathBatch* that = t->cast<AAFlatteningConvexPathBatch>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
@ -293,7 +283,7 @@ private:
fBatch.fCanTweakAlphaForCoverage = false;
}
fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
this->joinBounds(that->bounds());
return true;
}
@ -314,6 +304,15 @@ private:
bool fCanTweakAlphaForCoverage;
};
struct Geometry {
GrColor fColor;
SkMatrix fViewMatrix;
SkPath fPath;
SkScalar fStrokeWidth;
SkPaint::Join fJoin;
SkScalar fMiterLimit;
};
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
@ -326,17 +325,17 @@ bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
SkASSERT(!args.fDrawContext->isUnifiedMultisampled());
SkASSERT(!args.fShape->isEmpty());
AAFlatteningConvexPathBatch::Geometry geometry;
geometry.fColor = args.fColor;
geometry.fViewMatrix = *args.fViewMatrix;
args.fShape->asPath(&geometry.fPath);
SkPath path;
args.fShape->asPath(&path);
bool fill = args.fShape->style().isSimpleFill();
const SkStrokeRec& stroke = args.fShape->style().strokeRec();
geometry.fStrokeWidth = fill ? -1.0f : stroke.getWidth();
geometry.fJoin = fill ? SkPaint::Join::kMiter_Join : stroke.getJoin();
geometry.fMiterLimit = stroke.getMiter();
SkScalar strokeWidth = fill ? -1.0f : stroke.getWidth();
SkPaint::Join join = fill ? SkPaint::Join::kMiter_Join : stroke.getJoin();
SkScalar miterLimit = stroke.getMiter();
SkAutoTUnref<GrDrawBatch> batch(AAFlatteningConvexPathBatch::Create(geometry));
SkAutoTUnref<GrDrawBatch> batch(new AAFlatteningConvexPathBatch(args.fColor, *args.fViewMatrix,
path, strokeWidth, join,
miterLimit));
GrPipelineBuilder pipelineBuilder(*args.fPaint);
pipelineBuilder.setUserStencil(args.fUserStencilSettings);
@ -351,12 +350,13 @@ bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
#ifdef GR_TEST_UTILS
DRAW_BATCH_TEST_DEFINE(AAFlatteningConvexPathBatch) {
AAFlatteningConvexPathBatch::Geometry geometry;
geometry.fColor = GrRandomColor(random);
geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
geometry.fPath = GrTest::TestPathConvex(random);
return AAFlatteningConvexPathBatch::Create(geometry);
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
SkPath path = GrTest::TestPathConvex(random);
SkScalar strokeWidth = random->nextBool() ? -1.f : 2.f;
SkPaint::Join join = SkPaint::kMiter_Join;
SkScalar miterLimit = 0.5f;
return new AAFlatteningConvexPathBatch(color, viewMatrix, path, strokeWidth, join, miterLimit);
}
#endif

69
src/gpu/batches/GrDefaultPathRenderer.cpp
View File

@ -97,16 +97,22 @@ class DefaultPathBatch : public GrVertexBatch {
public:
DEFINE_BATCH_CLASS_ID
struct Geometry {
GrColor fColor;
SkPath fPath;
SkScalar fTolerance;
};
DefaultPathBatch(GrColor color, const SkPath& path, SkScalar tolerance,
uint8_t coverage, const SkMatrix& viewMatrix, bool isHairline,
const SkRect& devBounds)
: INHERITED(ClassID()) {
fBatch.fCoverage = coverage;
fBatch.fIsHairline = isHairline;
fBatch.fViewMatrix = viewMatrix;
fGeoData.emplace_back(Geometry{color, path, tolerance});
static GrDrawBatch* Create(const Geometry& geometry, uint8_t coverage,
const SkMatrix& viewMatrix, bool isHairline,
const SkRect& devBounds) {
return new DefaultPathBatch(geometry, coverage, viewMatrix, isHairline, devBounds);
this->setBounds(devBounds);
// This is b.c. hairlines are notionally infinitely thin so without expansion
// two overlapping lines could be reordered even though they hit the same pixels.
if (isHairline) {
fBounds.outset(0.5f, 0.5f);
}
}
const char* name() const override { return "DefaultPathBatch"; }
@ -256,25 +262,6 @@ private:
target->putBackVertices((size_t)(maxVertices - vertexOffset), (size_t)vertexStride);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
DefaultPathBatch(const Geometry& geometry, uint8_t coverage, const SkMatrix& viewMatrix,
bool isHairline, const SkRect& devBounds)
: INHERITED(ClassID()) {
fBatch.fCoverage = coverage;
fBatch.fIsHairline = isHairline;
fBatch.fViewMatrix = viewMatrix;
fGeoData.push_back(geometry);
this->setBounds(devBounds);
// This is b.c. hairlines are notionally infinitely thin so without expansion
// two overlapping lines could be reordered even though they hit the same pixels.
if (isHairline) {
fBounds.outset(0.5f, 0.5f);
}
}
bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
DefaultPathBatch* that = t->cast<DefaultPathBatch>();
if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
@ -298,7 +285,7 @@ private:
return false;
}
fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
this->joinBounds(that->bounds());
return true;
}
@ -417,6 +404,12 @@ private:
bool fIsHairline;
};
struct Geometry {
GrColor fColor;
SkPath fPath;
SkScalar fTolerance;
};
BatchTracker fBatch;
SkSTArray<1, Geometry, true> fGeoData;
@ -577,14 +570,9 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawContext* drawContext,
drawContext->drawBatch(pipelineBuilder, clip, batch);
} else {
DefaultPathBatch::Geometry geometry;
geometry.fColor = color;
geometry.fPath = path;
geometry.fTolerance = srcSpaceTol;
SkAutoTUnref<GrDrawBatch> batch(DefaultPathBatch::Create(geometry, newCoverage,
viewMatrix, isHairline,
devBounds));
SkAutoTUnref<GrDrawBatch> batch(new DefaultPathBatch(color, path, srcSpaceTol,
newCoverage, viewMatrix,
isHairline, devBounds));
GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
pipelineBuilder.setDrawFace(drawFace[p]);
@ -654,14 +642,9 @@ DRAW_BATCH_TEST_DEFINE(DefaultPathBatch) {
SkScalar tol = GrPathUtils::kDefaultTolerance;
SkScalar srcSpaceTol = GrPathUtils::scaleToleranceToSrc(tol, viewMatrix, bounds);
DefaultPathBatch::Geometry geometry;
geometry.fColor = color;
geometry.fPath = path;
geometry.fTolerance = srcSpaceTol;
viewMatrix.mapRect(&bounds);
uint8_t coverage = GrRandomCoverage(random);
return DefaultPathBatch::Create(geometry, coverage, viewMatrix, true, bounds);
return new DefaultPathBatch(color, path, srcSpaceTol, coverage, viewMatrix, true, bounds);
}
#endif

18
src/gpu/batches/GrDrawAtlasBatch.cpp
View File

@ -82,15 +82,16 @@ void GrDrawAtlasBatch::onPrepareDraws(Target* target) const {
helper.recordDraw(target, gp.get());
}
GrDrawAtlasBatch::GrDrawAtlasBatch(const Geometry& geometry, const SkMatrix& viewMatrix,
int spriteCount, const SkRSXform* xforms, const SkRect* rects,
GrDrawAtlasBatch::GrDrawAtlasBatch(GrColor color, const SkMatrix& viewMatrix, int spriteCount,
const SkRSXform* xforms, const SkRect* rects,
const SkColor* colors)
: INHERITED(ClassID()) {
: INHERITED(ClassID()) {
SkASSERT(xforms);
SkASSERT(rects);
fViewMatrix = viewMatrix;
Geometry& installedGeo = fGeoData.push_back(geometry);
Geometry& installedGeo = fGeoData.push_back();
installedGeo.fColor = color;
// Figure out stride and offsets
// Order within the vertex is: position [color] texCoord
@ -188,7 +189,7 @@ bool GrDrawAtlasBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
if (this->color() != that->color()) {
fColor = GrColor_ILLEGAL;
}
fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
fQuadCount += that->quadCount();
this->joinBounds(that->bounds());
@ -256,10 +257,9 @@ DRAW_BATCH_TEST_DEFINE(GrDrawAtlasBatch) {
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrDrawAtlasBatch::Geometry geometry;
geometry.fColor = GrRandomColor(random);
return GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount, xforms.begin(),
texRects.begin(), hasColors ? colors.begin() : nullptr);
GrColor color = GrRandomColor(random);
return new GrDrawAtlasBatch(color, viewMatrix, spriteCount, xforms.begin(), texRects.begin(),
hasColors ? colors.begin() : nullptr);
}
#endif

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

@ -16,16 +16,8 @@ class GrDrawAtlasBatch : public GrVertexBatch {
public:
DEFINE_BATCH_CLASS_ID
struct Geometry {
GrColor fColor;
SkTArray<uint8_t, true> fVerts;
};
static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
int spriteCount, const SkRSXform* xforms, const SkRect* rects,
const SkColor* colors) {
return new GrDrawAtlasBatch(geometry, viewMatrix, spriteCount, xforms, rects, colors);
}
GrDrawAtlasBatch(GrColor color, const SkMatrix& viewMatrix, int spriteCount,
const SkRSXform* xforms, const SkRect* rects, const SkColor* colors);
const char* name() const override { return "DrawAtlasBatch"; }
@ -41,16 +33,11 @@ public:
coverage->setKnownSingleComponent(0xff);
}
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
private:
void onPrepareDraws(Target*) const override;
void initBatchTracker(const GrXPOverridesForBatch&) override;
GrDrawAtlasBatch(const Geometry& geometry, const SkMatrix& viewMatrix, int spriteCount,
const SkRSXform* xforms, const SkRect* rects, const SkColor* colors);
GrColor color() const { return fColor; }
bool colorIgnored() const { return fColorIgnored; }
const SkMatrix& viewMatrix() const { return fViewMatrix; }
@ -59,6 +46,12 @@ private:
bool coverageIgnored() const { return fCoverageIgnored; }
bool onCombineIfPossible(GrBatch* t, const GrCaps&) override;
struct Geometry {
GrColor fColor;
SkTArray<uint8_t, true> fVerts;
};
SkSTArray<1, Geometry, true> fGeoData;
SkMatrix fViewMatrix;