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

ccpr: Handle winding and even-odd in the same shader

Browse Source 
We are already waiting for an entire texture lookup anyway. A couple
extra flops should still complete before the texture fetch. This also
gives us better batching.

TBR=bsalomon@google.com

Bug: skia:
Change-Id: I7b8e3021c8baad200af99600c9592df5ed0e46bd
Reviewed-on: https://skia-review.googlesource.com/129881
Reviewed-by: Chris Dalton <csmartdalton@google.com>
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Auto-Submit: Chris Dalton <csmartdalton@google.com>
This commit is contained in:
Chris Dalton 2018-05-23 17:11:09 -06:00 committed by Skia Commit-Bot
parent 13235d8966
commit daef06ae3b
9 changed files with 85 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/gpu/ccpr/GrCCClipPath.cpp
View File

@ -48,11 +48,12 @@ void GrCCClipPath::init(GrProxyProvider* proxyProvider,
fAccessRect = accessRect;
}
void GrCCClipPath::placePathInAtlas(GrCCPerFlushResources* resources,
GrOnFlushResourceProvider* onFlushRP) {
void GrCCClipPath::renderPathInAtlas(GrCCPerFlushResources* resources,
GrOnFlushResourceProvider* onFlushRP) {
SkASSERT(this->isInitialized());
SkASSERT(!fHasAtlas);
fAtlas = resources->addDeviceSpacePathToAtlas(*onFlushRP->caps(), fAccessRect, fDeviceSpacePath,
fPathDevIBounds, &fAtlasOffsetX, &fAtlasOffsetY);
fAtlas = resources->renderDeviceSpacePathInAtlas(*onFlushRP->caps(), fAccessRect,
fDeviceSpacePath, fPathDevIBounds,
&fAtlasOffsetX, &fAtlasOffsetY);
SkDEBUGCODE(fHasAtlas = true);
}

2
src/gpu/ccpr/GrCCClipPath.h
View File

@ -55,7 +55,7 @@ public:
return fPathDevIBounds;
}
void placePathInAtlas(GrCCPerFlushResources*, GrOnFlushResourceProvider*);
void renderPathInAtlas(GrCCPerFlushResources*, GrOnFlushResourceProvider*);
const SkVector& atlasScale() const { SkASSERT(fHasAtlasTransform); return fAtlasScale; }
const SkVector& atlasTranslate() const { SkASSERT(fHasAtlasTransform); return fAtlasTranslate; }

25
src/gpu/ccpr/GrCCDrawPathsOp.cpp
View File

@ -60,8 +60,7 @@ bool GrCCDrawPathsOp::onCombineIfPossible(GrOp* op, const GrCaps& caps) {
SkASSERT(!that->fOwningPerOpListPaths || that->fOwningPerOpListPaths == fOwningPerOpListPaths);
SkASSERT(that->fNumDraws);
if (this->getFillType() != that->getFillType() || fSRGBFlags != that->fSRGBFlags ||
fProcessors != that->fProcessors ||
if (fSRGBFlags != that->fSRGBFlags || fProcessors != that->fProcessors ||
fViewMatrixIfUsingLocalCoords != that->fViewMatrixIfUsingLocalCoords) {
return false;
}
@ -95,35 +94,35 @@ void GrCCDrawPathsOp::setupResources(GrCCPerFlushResources* resources,
const GrCCAtlas* currentAtlas = nullptr;
SkASSERT(fNumDraws > 0);
SkASSERT(-1 == fBaseInstance);
fBaseInstance = resources->pathInstanceCount();
fBaseInstance = resources->nextPathInstanceIdx();
for (const SingleDraw& draw : fDraws) {
// addPathToAtlas gives us two tight bounding boxes: one in device space, as well as a
// renderPathInAtlas gives us two tight bounding boxes: one in device space, as well as a
// second one rotated an additional 45 degrees. The path vertex shader uses these two
// bounding boxes to generate an octagon that circumscribes the path.
SkRect devBounds, devBounds45;
int16_t atlasOffsetX, atlasOffsetY;
GrCCAtlas* atlas = resources->addPathToAtlas(*onFlushRP->caps(), draw.fClipIBounds,
draw.fMatrix, draw.fPath, &devBounds,
&devBounds45, &atlasOffsetX, &atlasOffsetY);
GrCCAtlas* atlas = resources->renderPathInAtlas(*onFlushRP->caps(), draw.fClipIBounds,
draw.fMatrix, draw.fPath, &devBounds,
&devBounds45, &atlasOffsetX, &atlasOffsetY);
if (!atlas) {
SkDEBUGCODE(++fNumSkippedInstances);
continue;
}
if (currentAtlas != atlas) {
if (currentAtlas) {
this->addAtlasBatch(currentAtlas, resources->pathInstanceCount());
this->addAtlasBatch(currentAtlas, resources->nextPathInstanceIdx());
}
currentAtlas = atlas;
}
resources->appendDrawPathInstance() =
{devBounds, devBounds45, {{atlasOffsetX, atlasOffsetY}}, draw.fColor};
resources->appendDrawPathInstance().set(draw.fPath.getFillType(), devBounds, devBounds45,
atlasOffsetX, atlasOffsetY, draw.fColor);
}
SkASSERT(resources->pathInstanceCount() == fBaseInstance + fNumDraws - fNumSkippedInstances);
SkASSERT(resources->nextPathInstanceIdx() == fBaseInstance + fNumDraws - fNumSkippedInstances);
if (currentAtlas) {
this->addAtlasBatch(currentAtlas, resources->pathInstanceCount());
this->addAtlasBatch(currentAtlas, resources->nextPathInstanceIdx());
}
}
@ -156,7 +155,7 @@ void GrCCDrawPathsOp::onExecute(GrOpFlushState* flushState) {
}
GrCCPathProcessor pathProc(flushState->resourceProvider(),
sk_ref_sp(batch.fAtlas->textureProxy()), this->getFillType(),
sk_ref_sp(batch.fAtlas->textureProxy()),
fViewMatrixIfUsingLocalCoords);
pathProc.drawPaths(flushState, pipeline, resources->indexBuffer(),
resources->vertexBuffer(), resources->instanceBuffer(),

5
src/gpu/ccpr/GrCCDrawPathsOp.h
View File

@ -48,11 +48,6 @@ public:
void onExecute(GrOpFlushState*) override;
private:
SkPath::FillType getFillType() const {
SkASSERT(fNumDraws >= 1);
return fDraws.head().fPath.getFillType();
}
struct AtlasBatch {
const GrCCAtlas* fAtlas;
int fEndInstanceIdx;

44
src/gpu/ccpr/GrCCPathProcessor.cpp
View File

@ -76,10 +76,9 @@ sk_sp<const GrBuffer> GrCCPathProcessor::FindIndexBuffer(GrOnFlushResourceProvid
}
GrCCPathProcessor::GrCCPathProcessor(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> atlas, SkPath::FillType fillType,
sk_sp<GrTextureProxy> atlas,
const SkMatrix& viewMatrixIfUsingLocalCoords)
: INHERITED(kGrCCPathProcessor_ClassID)
, fFillType(fillType)
, fAtlasAccess(std::move(atlas), GrSamplerState::Filter::kNearest,
GrSamplerState::WrapMode::kClamp, kFragment_GrShaderFlag) {
this->addInstanceAttrib("devbounds", kFloat4_GrVertexAttribType);
@ -113,10 +112,6 @@ GrCCPathProcessor::GrCCPathProcessor(GrResourceProvider* resourceProvider,
}
}
void GrCCPathProcessor::getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
b->add32((fFillType << 16) | this->atlasProxy()->origin());
}
class GLSLPathProcessor : public GrGLSLGeometryProcessor {
public:
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override;
@ -173,7 +168,7 @@ void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
varyingHandler->emitAttributes(proc);
GrGLSLVarying texcoord(kFloat2_GrSLType);
GrGLSLVarying texcoord(kFloat3_GrSLType);
GrGLSLVarying color(kHalf4_GrSLType);
varyingHandler->addVarying("texcoord", &texcoord);
varyingHandler->addPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor),
@ -193,9 +188,11 @@ void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
// N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing
// out of the octagon.
v->codeAppendf("float2 refpt = (0 == sk_VertexID >> 2) ? %s.xy : %s.zw;",
proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName,
v->codeAppendf("float4 devbounds = %s;",
proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName);
v->codeAppend ("float2 refpt = (0 == sk_VertexID >> 2)"
"? float2(min(devbounds.x, devbounds.z), devbounds.y)"
": float2(max(devbounds.x, devbounds.z), devbounds.w);");
v->codeAppendf("refpt += N[0] * %f;", kAABloatRadius); // bloat for AA.
// N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing
@ -215,12 +212,15 @@ void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
v->codeAppendf("float2 atlascoord = octocoord + float2(%s);",
proc.getInstanceAttrib(InstanceAttribs::kAtlasOffset).fName);
if (kTopLeft_GrSurfaceOrigin == proc.atlasProxy()->origin()) {
v->codeAppendf("%s = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
v->codeAppendf("%s.xy = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
} else {
SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.atlasProxy()->origin());
v->codeAppendf("%s = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
v->codeAppendf("%s.xy = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
texcoord.vsOut(), atlasAdjust, atlasAdjust);
}
// The third texture coordinate is -.5 for even-odd paths and +.5 for winding ones.
// ("right < left" indicates even-odd fill type.)
v->codeAppendf("%s.z = sign(devbounds.z - devbounds.x) * .5;", texcoord.vsOut());
this->emitTransforms(v, varyingHandler, uniHandler, GrShaderVar("octocoord", kFloat2_GrSLType),
proc.localMatrix(), args.fFPCoordTransformHandler);
@ -228,15 +228,19 @@ void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
// Fragment shader.
GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
f->codeAppend ("half coverage_count = ");
f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kFloat2_GrSLType);
// Look up coverage count in the atlas.
f->codeAppend ("half coverage = ");
f->appendTextureLookup(args.fTexSamplers[0], SkStringPrintf("%s.xy", texcoord.fsIn()).c_str(),
kFloat2_GrSLType);
f->codeAppend (".a;");
if (SkPath::kWinding_FillType == proc.fillType()) {
f->codeAppendf("%s = half4(min(abs(coverage_count), 1));", args.fOutputCoverage);
} else {
SkASSERT(SkPath::kEvenOdd_FillType == proc.fillType());
f->codeAppend ("half t = mod(abs(coverage_count), 2);");
f->codeAppendf("%s = half4(1 - abs(t - 1));", args.fOutputCoverage);
}
// Scale coverage count by .5. Make it negative for even-odd paths and positive for winding
// ones. Clamp winding coverage counts at 1.0 (i.e. min(coverage/2, .5)).
f->codeAppendf("coverage = min(abs(coverage) * %s.z, .5);", texcoord.fsIn());
// For negative values, this finishes the even-odd sawtooth function. Since positive (winding)
// values were clamped at "coverage/2 = .5", this only undoes the previous multiply by .5.
f->codeAppend ("coverage = 1 - abs(fract(coverage) * 2 - 1);");
f->codeAppendf("%s = half4(coverage);", args.fOutputCoverage);
}

26
src/gpu/ccpr/GrCCPathProcessor.h
View File

@ -38,13 +38,14 @@ public:
static constexpr int kNumInstanceAttribs = 1 + (int)InstanceAttribs::kColor;
struct Instance {
SkRect fDevBounds;
SkRect fDevBounds; // "right < left" indicates even-odd fill type.
SkRect fDevBounds45; // Bounding box in "| 1 -1 | * devCoords" space.
// | 1 1 |
std::array<int16_t, 2> fAtlasOffset;
uint32_t fColor;
GR_STATIC_ASSERT(SK_SCALAR_IS_FLOAT);
void set(SkPath::FillType, const SkRect& devBounds, const SkRect& devBounds45,
int16_t atlasOffsetX, int16_t atlasOffsetY, uint32_t color);
};
GR_STATIC_ASSERT(4 * 10 == sizeof(Instance));
@ -52,14 +53,13 @@ public:
static sk_sp<const GrBuffer> FindVertexBuffer(GrOnFlushResourceProvider*);
static sk_sp<const GrBuffer> FindIndexBuffer(GrOnFlushResourceProvider*);
GrCCPathProcessor(GrResourceProvider*, sk_sp<GrTextureProxy> atlas, SkPath::FillType,
GrCCPathProcessor(GrResourceProvider*, sk_sp<GrTextureProxy> atlas,
const SkMatrix& viewMatrixIfUsingLocalCoords = SkMatrix::I());
const char* name() const override { return "GrCCPathProcessor"; }
const GrSurfaceProxy* atlasProxy() const { return fAtlasAccess.proxy(); }
const GrTexture* atlas() const { return fAtlasAccess.peekTexture(); }
const SkMatrix& localMatrix() const { return fLocalMatrix; }
SkPath::FillType fillType() const { return fFillType; }
const Attribute& getInstanceAttrib(InstanceAttribs attribID) const {
const Attribute& attrib = this->getAttrib((int)attribID);
SkASSERT(Attribute::InputRate::kPerInstance == attrib.fInputRate);
@ -72,7 +72,7 @@ public:
return attrib;
}
void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override;
void drawPaths(GrOpFlushState*, const GrPipeline&, const GrBuffer* indexBuffer,
@ -80,11 +80,25 @@ public:
int endInstance, const SkRect& bounds) const;
private:
const SkPath::FillType fFillType;
const TextureSampler fAtlasAccess;
SkMatrix fLocalMatrix;
typedef GrGeometryProcessor INHERITED;
};
inline void GrCCPathProcessor::Instance::set(SkPath::FillType fillType, const SkRect& devBounds,
const SkRect& devBounds45, int16_t atlasOffsetX,
int16_t atlasOffsetY, uint32_t color) {
if (SkPath::kEvenOdd_FillType == fillType) {
// "right < left" indicates even-odd fill type.
fDevBounds.setLTRB(devBounds.fRight, devBounds.fTop, devBounds.fLeft, devBounds.fBottom);
} else {
SkASSERT(SkPath::kWinding_FillType == fillType);
fDevBounds = devBounds;
}
fDevBounds45 = devBounds45;
fAtlasOffset = {{atlasOffsetX, atlasOffsetY}};
fColor = color;
}
#endif

20
src/gpu/ccpr/GrCCPerFlushResources.cpp
View File

@ -38,10 +38,10 @@ GrCCPerFlushResources::GrCCPerFlushResources(GrOnFlushResourceProvider* onFlushR
SkDEBUGCODE(fPathInstanceBufferCount = numPathDraws);
}
GrCCAtlas* GrCCPerFlushResources::addPathToAtlas(const GrCaps& caps, const SkIRect& clipIBounds,
const SkMatrix& m, const SkPath& path,
SkRect* devBounds, SkRect* devBounds45,
int16_t* atlasOffsetX, int16_t* atlasOffsetY) {
GrCCAtlas* GrCCPerFlushResources::renderPathInAtlas(const GrCaps& caps, const SkIRect& clipIBounds,
const SkMatrix& m, const SkPath& path,
SkRect* devBounds, SkRect* devBounds45,
int16_t* atlasOffsetX, int16_t* atlasOffsetY) {
SkASSERT(this->isMapped());
SkIRect devIBounds;
fPathParser->parsePath(m, path, devBounds, devBounds45);
@ -49,12 +49,12 @@ GrCCAtlas* GrCCPerFlushResources::addPathToAtlas(const GrCaps& caps, const SkIRe
return this->placeParsedPathInAtlas(caps, clipIBounds, devIBounds, atlasOffsetX, atlasOffsetY);
}
GrCCAtlas* GrCCPerFlushResources::addDeviceSpacePathToAtlas(const GrCaps& caps,
const SkIRect& clipIBounds,
const SkPath& devPath,
const SkIRect& devPathIBounds,
int16_t* atlasOffsetX,
int16_t* atlasOffsetY) {
GrCCAtlas* GrCCPerFlushResources::renderDeviceSpacePathInAtlas(const GrCaps& caps,
const SkIRect& clipIBounds,
const SkPath& devPath,
const SkIRect& devPathIBounds,
int16_t* atlasOffsetX,
int16_t* atlasOffsetY) {
SkASSERT(this->isMapped());
fPathParser->parseDeviceSpacePath(devPath);
return this->placeParsedPathInAtlas(caps, clipIBounds, devPathIBounds, atlasOffsetX,

23
src/gpu/ccpr/GrCCPerFlushResources.h
View File

@ -26,22 +26,21 @@ public:
bool isMapped() const { return SkToBool(fPathInstanceData); }
GrCCAtlas* addPathToAtlas(const GrCaps&, const SkIRect& clipIBounds, const SkMatrix&,
const SkPath&, SkRect* devBounds, SkRect* devBounds45,
int16_t* offsetX, int16_t* offsetY);
GrCCAtlas* addDeviceSpacePathToAtlas(const GrCaps&, const SkIRect& clipIBounds,
const SkPath& devPath, const SkIRect& devPathIBounds,
int16_t* atlasOffsetX, int16_t* atlasOffsetY);
GrCCAtlas* renderPathInAtlas(const GrCaps&, const SkIRect& clipIBounds, const SkMatrix&,
const SkPath&, SkRect* devBounds, SkRect* devBounds45,
int16_t* offsetX, int16_t* offsetY);
GrCCAtlas* renderDeviceSpacePathInAtlas(const GrCaps&, const SkIRect& clipIBounds,
const SkPath& devPath, const SkIRect& devPathIBounds,
int16_t* atlasOffsetX, int16_t* atlasOffsetY);
GrCCPathProcessor::Instance& appendDrawPathInstance() {
SkASSERT(this->isMapped());
SkASSERT(fPathInstanceCount < fPathInstanceBufferCount);
return fPathInstanceData[fPathInstanceCount++];
SkASSERT(fNextPathInstanceIdx < fPathInstanceBufferCount);
return fPathInstanceData[fNextPathInstanceIdx++];
}
int pathInstanceCount() const { return fPathInstanceCount; }
int nextPathInstanceIdx() const { return fNextPathInstanceIdx; }
bool finalize(GrOnFlushResourceProvider*,
SkTArray<sk_sp<GrRenderTargetContext>>* atlasDraws);
bool finalize(GrOnFlushResourceProvider*, SkTArray<sk_sp<GrRenderTargetContext>>* atlasDraws);
const GrBuffer* indexBuffer() const { SkASSERT(!this->isMapped()); return fIndexBuffer.get(); }
const GrBuffer* vertexBuffer() const { SkASSERT(!this->isMapped()); return fVertexBuffer.get();}
@ -59,7 +58,7 @@ private:
sk_sp<GrBuffer> fInstanceBuffer;
GrCCPathProcessor::Instance* fPathInstanceData = nullptr;
int fPathInstanceCount = 0;
int fNextPathInstanceIdx = 0;
SkDEBUGCODE(int fPathInstanceBufferCount);
GrSTAllocator<4, GrCCAtlas> fAtlases;

4
src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
View File

@ -215,10 +215,10 @@ void GrCoverageCountingPathRenderer::preFlush(GrOnFlushResourceProvider* onFlush
SkDEBUGCODE(numSkippedPaths += op->numSkippedInstances_debugOnly());
}
for (auto& clipsIter : flushingPaths->fClipPaths) {
clipsIter.second.placePathInAtlas(resources.get(), onFlushRP);
clipsIter.second.renderPathInAtlas(resources.get(), onFlushRP);
}
}
SkASSERT(resources->pathInstanceCount() == numPathDraws - numSkippedPaths);
SkASSERT(resources->nextPathInstanceIdx() == numPathDraws - numSkippedPaths);
// Allocate the atlases and create instance buffers to draw them.
if (!resources->finalize(onFlushRP, atlasDraws)) {