Revert "Stack-allocate pipelines for GrMeshDrawOp"
This reverts commit dfe5000a5ff2cabb50ddc139882dc1f3005fa429.
Reason for revert: HWAA pipeline flag not getting set for dashing.
Original change's description:
> Stack-allocate pipelines for GrMeshDrawOp
>
> Stack-allocates the pipelines in onExecute. This saves us from having
> to store the pipelines on the heap, as well as delaying the need to
> detach processors until onExecute. The delay is an improvement because
> it allows us to keep visiting proxies after onPrepare. (Previously,
> they were moved out of GrProcessorSet and into a pipeline during
> onPrepare, so visiting proxies was impossible after that point.)
>
> Bug: skia:8731
> Change-Id: Idc05063fb0dfbfed42b434e429fa5a497097bdae
> Reviewed-on: https://skia-review.googlesource.com/c/193368
> Commit-Queue: Chris Dalton <csmartdalton@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>
TBR=robertphillips@google.com,csmartdalton@google.com
Change-Id: If706f19423310846de70288f393ac12f17ffeee5
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:8731
Reviewed-on: https://skia-review.googlesource.com/c/195161
Reviewed-by: Chris Dalton <csmartdalton@google.com>
Commit-Queue: Chris Dalton <csmartdalton@google.com>
diff --git a/src/gpu/GrOpFlushState.cpp b/src/gpu/GrOpFlushState.cpp
index a02b2f4..7b983c4 100644
--- a/src/gpu/GrOpFlushState.cpp
+++ b/src/gpu/GrOpFlushState.cpp
@@ -32,19 +32,8 @@
return fCommandBuffer->asRTCommandBuffer();
}
-void GrOpFlushState::executeDrawsAndUploadsForMeshDrawOp(
- const GrOp* op, const SkRect& chainBounds, GrProcessorSet&& processorSet,
- uint32_t pipelineFlags, const GrUserStencilSettings* stencilSettings) {
+void GrOpFlushState::executeDrawsAndUploadsForMeshDrawOp(const GrOp* op, const SkRect& opBounds) {
SkASSERT(this->rtCommandBuffer());
-
- GrPipeline::InitArgs pipelineArgs;
- pipelineArgs.fFlags = pipelineFlags;
- pipelineArgs.fDstProxy = this->dstProxy();
- pipelineArgs.fCaps = &this->caps();
- pipelineArgs.fResourceProvider = this->resourceProvider();
- pipelineArgs.fUserStencil = stencilSettings;
- GrPipeline pipeline(pipelineArgs, std::move(processorSet), this->detachAppliedClip());
-
while (fCurrDraw != fDraws.end() && fCurrDraw->fOp == op) {
GrDeferredUploadToken drawToken = fTokenTracker->nextTokenToFlush();
while (fCurrUpload != fInlineUploads.end() &&
@@ -52,10 +41,9 @@
this->rtCommandBuffer()->inlineUpload(this, fCurrUpload->fUpload);
++fCurrUpload;
}
- this->rtCommandBuffer()->draw(
- *fCurrDraw->fGeometryProcessor, pipeline, fCurrDraw->fFixedDynamicState,
- fCurrDraw->fDynamicStateArrays, fCurrDraw->fMeshes, fCurrDraw->fMeshCnt,
- chainBounds);
+ this->rtCommandBuffer()->draw(*fCurrDraw->fGeometryProcessor, *fCurrDraw->fPipeline,
+ fCurrDraw->fFixedDynamicState, fCurrDraw->fDynamicStateArrays,
+ fCurrDraw->fMeshes, fCurrDraw->fMeshCnt, opBounds);
fTokenTracker->flushToken();
++fCurrDraw;
}
@@ -110,10 +98,10 @@
return fTokenTracker->nextTokenToFlush();
}
-void GrOpFlushState::recordDraw(
- sk_sp<const GrGeometryProcessor> gp, const GrMesh meshes[], int meshCnt,
- const GrPipeline::FixedDynamicState* fixedDynamicState,
- const GrPipeline::DynamicStateArrays* dynamicStateArrays) {
+void GrOpFlushState::draw(sk_sp<const GrGeometryProcessor> gp, const GrPipeline* pipeline,
+ const GrPipeline::FixedDynamicState* fixedDynamicState,
+ const GrPipeline::DynamicStateArrays* dynamicStateArrays,
+ const GrMesh meshes[], int meshCnt) {
SkASSERT(fOpArgs);
SkASSERT(fOpArgs->fOp);
bool firstDraw = fDraws.begin() == fDraws.end();
@@ -131,6 +119,7 @@
}
}
draw.fGeometryProcessor = std::move(gp);
+ draw.fPipeline = pipeline;
draw.fFixedDynamicState = fixedDynamicState;
draw.fDynamicStateArrays = dynamicStateArrays;
draw.fMeshes = meshes;
diff --git a/src/gpu/GrOpFlushState.h b/src/gpu/GrOpFlushState.h
index 07983d4..54aa4dd 100644
--- a/src/gpu/GrOpFlushState.h
+++ b/src/gpu/GrOpFlushState.h
@@ -41,9 +41,7 @@
void doUpload(GrDeferredTextureUploadFn&);
/** Called as ops are executed. Must be called in the same order as the ops were prepared. */
- void executeDrawsAndUploadsForMeshDrawOp(
- const GrOp* op, const SkRect& chainBounds, GrProcessorSet&&, uint32_t pipelineFlags = 0,
- const GrUserStencilSettings* = &GrUserStencilSettings::kUnused);
+ void executeDrawsAndUploadsForMeshDrawOp(const GrOp* op, const SkRect& opBounds);
GrGpuCommandBuffer* commandBuffer() { return fCommandBuffer; }
// Helper function used by Ops that are only called via RenderTargetOpLists
@@ -81,9 +79,12 @@
GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&&) final;
/** Overrides of GrMeshDrawOp::Target. */
- void recordDraw(
- sk_sp<const GrGeometryProcessor>, const GrMesh[], int meshCnt,
- const GrPipeline::FixedDynamicState*, const GrPipeline::DynamicStateArrays*) final;
+ void draw(sk_sp<const GrGeometryProcessor>,
+ const GrPipeline*,
+ const GrPipeline::FixedDynamicState*,
+ const GrPipeline::DynamicStateArrays*,
+ const GrMesh[],
+ int meshCnt) final;
void* makeVertexSpace(size_t vertexSize, int vertexCount, sk_sp<const GrBuffer>*,
int* startVertex) final;
uint16_t* makeIndexSpace(int indexCount, sk_sp<const GrBuffer>*, int* startIndex) final;
@@ -96,7 +97,6 @@
void putBackIndices(int indexCount) final;
void putBackVertices(int vertices, size_t vertexStride) final;
GrRenderTargetProxy* proxy() const final { return fOpArgs->fProxy; }
- const GrAppliedClip* appliedClip() final { return fOpArgs->fAppliedClip; }
GrAppliedClip detachAppliedClip() final;
const GrXferProcessor::DstProxy& dstProxy() const final { return fOpArgs->fDstProxy; }
GrDeferredUploadTarget* deferredUploadTarget() final { return this; }
@@ -113,7 +113,7 @@
private:
/** GrMeshDrawOp::Target override. */
- SkArenaAlloc* allocator() override { return &fArena; }
+ SkArenaAlloc* pipelineArena() override { return &fArena; }
struct InlineUpload {
InlineUpload(GrDeferredTextureUploadFn&& upload, GrDeferredUploadToken token)
@@ -129,6 +129,7 @@
struct Draw {
~Draw();
sk_sp<const GrGeometryProcessor> fGeometryProcessor;
+ const GrPipeline* fPipeline = nullptr;
const GrPipeline::FixedDynamicState* fFixedDynamicState;
const GrPipeline::DynamicStateArrays* fDynamicStateArrays;
const GrMesh* fMeshes = nullptr;
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 1e44b87..cb9d364 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -713,6 +713,7 @@
private:
void onPrepareDraws(Target* target) override {
+ auto pipe = fHelper.makePipeline(target);
int instanceCount = fPaths.count();
SkMatrix invert;
@@ -793,14 +794,11 @@
firstIndex += draw.fIndexCnt;
firstVertex += draw.fVertexCnt;
}
- target->recordDraw(quadProcessor, meshes, draws.count());
+ target->draw(quadProcessor, pipe.fPipeline, pipe.fFixedDynamicState, nullptr, meshes,
+ draws.count());
}
}
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
- }
-
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AAConvexPathOp* that = t->cast<AAConvexPathOp>();
if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 0933a23..877a522 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -845,7 +845,6 @@
private:
void onPrepareDraws(Target*) override;
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
typedef SkTArray<SkPoint, true> PtArray;
typedef SkTArray<int, true> IntArray;
@@ -955,6 +954,7 @@
return;
}
+ auto pipe = fHelper.makePipeline(target);
// do lines first
if (lineCount) {
sk_sp<GrGeometryProcessor> lineGP;
@@ -993,7 +993,7 @@
mesh->setIndexedPatterned(std::move(linesIndexBuffer), kIdxsPerLineSeg, kLineSegNumVertices,
lineCount, kLineSegsNumInIdxBuffer);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(lineGP), mesh);
+ target->draw(std::move(lineGP), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
if (quadCount || conicCount) {
@@ -1048,7 +1048,7 @@
mesh->setIndexedPatterned(quadsIndexBuffer, kIdxsPerQuad, kQuadNumVertices, quadCount,
kQuadsNumInIdxBuffer);
mesh->setVertexData(vertexBuffer, firstVertex);
- target->recordDraw(std::move(quadGP), mesh);
+ target->draw(std::move(quadGP), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
firstVertex += quadCount * kQuadNumVertices;
}
@@ -1057,15 +1057,11 @@
mesh->setIndexedPatterned(std::move(quadsIndexBuffer), kIdxsPerQuad, kQuadNumVertices,
conicCount, kQuadsNumInIdxBuffer);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(conicGP), mesh);
+ target->draw(std::move(conicGP), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
}
}
-void AAHairlineOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
-}
-
bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrAAHairlinePathRenderer::onDrawPath");
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index 4ade866..6205b84 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -193,8 +193,9 @@
}
private:
- void recordDraw(Target* target, sk_sp<const GrGeometryProcessor> gp, int vertexCount,
- size_t vertexStride, void* vertices, int indexCount, uint16_t* indices) const {
+ void draw(Target* target, sk_sp<const GrGeometryProcessor> gp, const GrPipeline* pipeline,
+ const GrPipeline::FixedDynamicState* fixedDynamicState, int vertexCount,
+ size_t vertexStride, void* vertices, int indexCount, uint16_t* indices) const {
if (vertexCount == 0 || indexCount == 0) {
return;
}
@@ -220,10 +221,11 @@
mesh->setIndexed(std::move(indexBuffer), indexCount, firstIndex, 0, vertexCount - 1,
GrPrimitiveRestart::kNo);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
+ target->draw(std::move(gp), pipeline, fixedDynamicState, mesh);
}
void onPrepareDraws(Target* target) override {
+ auto pipe = fHelper.makePipeline(target);
// Setup GrGeometryProcessor
sk_sp<GrGeometryProcessor> gp(create_lines_only_gp(target->caps().shaderCaps(),
fHelper.compatibleWithAlphaAsCoverage(),
@@ -257,8 +259,8 @@
if (vertexCount + currentVertices > static_cast<int>(UINT16_MAX)) {
// if we added the current instance, we would overflow the indices we can store in a
// uint16_t. Draw what we've got so far and reset.
- this->recordDraw(
- target, gp, vertexCount, vertexStride, vertices, indexCount, indices);
+ this->draw(target, gp, pipe.fPipeline, pipe.fFixedDynamicState, vertexCount,
+ vertexStride, vertices, indexCount, indices);
vertexCount = 0;
indexCount = 0;
}
@@ -289,17 +291,13 @@
indexCount += currentIndices;
}
if (vertexCount <= SK_MaxS32 && indexCount <= SK_MaxS32) {
- this->recordDraw(target, std::move(gp), vertexCount, vertexStride, vertices, indexCount,
- indices);
+ this->draw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, vertexCount,
+ vertexStride, vertices, indexCount, indices);
}
sk_free(vertices);
sk_free(indices);
}
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
- }
-
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
AAFlatteningConvexPathOp* that = t->cast<AAFlatteningConvexPathOp>();
if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index fae54df..8e231cb 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -298,13 +298,16 @@
GR_STATIC_ASSERT(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
GR_STATIC_ASSERT(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
- auto fixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
+ static const uint32_t kPipelineFlags = 0;
+ auto pipe = target->makePipeline(kPipelineFlags, std::move(fProcessors),
+ target->detachAppliedClip(), kMaxTextures);
for (unsigned i = 0; i < numActiveProxies; ++i) {
- fixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
+ pipe.fFixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
}
FlushInfo flushInfo;
- flushInfo.fFixedDynamicState = fixedDynamicState;
+ flushInfo.fPipeline = pipe.fPipeline;
+ flushInfo.fFixedDynamicState = pipe.fFixedDynamicState;
bool vmPerspective = fGeoData[0].fViewMatrix.hasPerspective();
if (this->usesDistanceFields()) {
@@ -386,12 +389,6 @@
this->flush(target, &flushInfo);
}
-void GrAtlasTextOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- static const uint32_t kPipelineFlags = 0;
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, std::move(fProcessors), kPipelineFlags);
-}
-
void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const {
if (!flushInfo->fGlyphsToFlush) {
return;
@@ -431,8 +428,8 @@
mesh->setIndexedPatterned(flushInfo->fIndexBuffer, kIndicesPerGlyph, kVerticesPerGlyph,
flushInfo->fGlyphsToFlush, maxGlyphsPerDraw);
mesh->setVertexData(flushInfo->fVertexBuffer, flushInfo->fVertexOffset);
- target->recordDraw(
- flushInfo->fGeometryProcessor, mesh, 1, flushInfo->fFixedDynamicState, nullptr);
+ target->draw(flushInfo->fGeometryProcessor, flushInfo->fPipeline, flushInfo->fFixedDynamicState,
+ mesh);
flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
flushInfo->fGlyphsToFlush = 0;
}
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index 8f5ff20..d8d453a 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -107,13 +107,13 @@
sk_sp<const GrBuffer> fVertexBuffer;
sk_sp<const GrBuffer> fIndexBuffer;
sk_sp<GrGeometryProcessor> fGeometryProcessor;
+ const GrPipeline* fPipeline;
GrPipeline::FixedDynamicState* fFixedDynamicState;
int fGlyphsToFlush;
int fVertexOffset;
};
void onPrepareDraws(Target*) override;
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
GrMaskFormat maskFormat() const {
switch (fMaskType) {
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 9bf2f9a..ca97f29 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -621,12 +621,9 @@
if (AAMode::kCoverageWithMSAA == fAAMode) {
pipelineFlags |= GrPipeline::kHWAntialias_Flag;
}
- helper.recordDraw(target, std::move(gp));
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, std::move(fProcessorSet));
+ auto pipe = target->makePipeline(pipelineFlags, std::move(fProcessorSet),
+ target->detachAppliedClip());
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 1ac80e6..7b50162 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -66,11 +66,14 @@
class PathGeoBuilder {
public:
PathGeoBuilder(GrPrimitiveType primitiveType, GrMeshDrawOp::Target* target,
- sk_sp<const GrGeometryProcessor> geometryProcessor)
+ sk_sp<const GrGeometryProcessor> geometryProcessor, const GrPipeline* pipeline,
+ const GrPipeline::FixedDynamicState* fixedDynamicState)
: fPrimitiveType(primitiveType)
, fTarget(target)
, fVertexStride(sizeof(SkPoint))
, fGeometryProcessor(std::move(geometryProcessor))
+ , fPipeline(pipeline)
+ , fFixedDynamicState(fixedDynamicState)
, fFirstIndex(0)
, fIndicesInChunk(0)
, fIndices(nullptr) {
@@ -276,7 +279,7 @@
vertexCount - 1, GrPrimitiveRestart::kNo);
}
mesh->setVertexData(std::move(fVertexBuffer), fFirstVertex);
- fTarget->recordDraw(fGeometryProcessor, mesh);
+ fTarget->draw(fGeometryProcessor, fPipeline, fFixedDynamicState, mesh);
}
fTarget->putBackIndices((size_t)(fIndicesInChunk - indexCount));
@@ -313,6 +316,8 @@
GrMeshDrawOp::Target* fTarget;
size_t fVertexStride;
sk_sp<const GrGeometryProcessor> fGeometryProcessor;
+ const GrPipeline* fPipeline;
+ const GrPipeline::FixedDynamicState* fFixedDynamicState;
sk_sp<const GrBuffer> fVertexBuffer;
int fFirstVertex;
@@ -425,7 +430,9 @@
} else {
primitiveType = GrPrimitiveType::kTriangles;
}
- PathGeoBuilder pathGeoBuilder(primitiveType, target, std::move(gp));
+ auto pipe = fHelper.makePipeline(target);
+ PathGeoBuilder pathGeoBuilder(primitiveType, target, std::move(gp), pipe.fPipeline,
+ pipe.fFixedDynamicState);
// fill buffers
for (int i = 0; i < instanceCount; i++) {
@@ -434,10 +441,6 @@
}
}
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
- }
-
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
DefaultPathOp* that = t->cast<DefaultPathOp>();
if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp
index 6dfeb3b..e37e960 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -48,7 +48,6 @@
private:
void onPrepareDraws(Target*) override;
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
const SkPMColor4f& color() const { return fColor; }
const SkMatrix& viewMatrix() const { return fViewMatrix; }
@@ -207,11 +206,8 @@
memcpy(vertPtr, args.fVerts.begin(), allocSize);
vertPtr += allocSize;
}
- helper.recordDraw(target, std::move(gp));
-}
-
-void DrawAtlasOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
GrOp::CombineResult DrawAtlasOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index f1589ed..ec82f87 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -47,7 +47,6 @@
};
void onPrepareDraws(Target*) override;
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
void drawVolatile(Target*);
void drawNonVolatile(Target*);
@@ -503,11 +502,8 @@
mesh->setNonIndexedNonInstanced(fVertexCount);
}
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
-}
-
-void DrawVerticesOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
GrOp::CombineResult DrawVerticesOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
index 1712433..1d4e13c 100644
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ b/src/gpu/ops/GrFillRectOp.cpp
@@ -227,12 +227,10 @@
return;
}
mesh->setVertexData(std::move(vbuffer), vertexOffsetInBuffer);
- target->recordDraw(std::move(gp), mesh);
- }
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
- }
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
+ }
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
TRACE_EVENT0("skia", TRACE_FUNC);
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 4d49c6e..dcb88d3 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -284,13 +284,9 @@
kVertsPerRect * patch.fIter->numRectsToDraw());
}
}
- auto fixedDynamicState = target->makeFixedDynamicState(1);
- fixedDynamicState->fPrimitiveProcessorTextures[0] = fProxy.get();
- helper.recordDraw(target, std::move(gp), fixedDynamicState);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target, 1);
+ pipe.fFixedDynamicState->fPrimitiveProcessorTextures[0] = fProxy.get();
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
diff --git a/src/gpu/ops/GrMeshDrawOp.cpp b/src/gpu/ops/GrMeshDrawOp.cpp
index a8ad863..ac019f3 100644
--- a/src/gpu/ops/GrMeshDrawOp.cpp
+++ b/src/gpu/ops/GrMeshDrawOp.cpp
@@ -14,6 +14,10 @@
void GrMeshDrawOp::onPrepare(GrOpFlushState* state) { this->onPrepareDraws(state); }
+void GrMeshDrawOp::onExecute(GrOpFlushState* state, const SkRect& chainBounds) {
+ state->executeDrawsAndUploadsForMeshDrawOp(this, chainBounds);
+}
+
//////////////////////////////////////////////////////////////////////////////
GrMeshDrawOp::PatternHelper::PatternHelper(Target* target, GrPrimitiveType primitiveType,
@@ -50,14 +54,9 @@
}
void GrMeshDrawOp::PatternHelper::recordDraw(
- Target* target, sk_sp<const GrGeometryProcessor> gp) const {
- target->recordDraw(std::move(gp), fMesh);
-}
-
-void GrMeshDrawOp::PatternHelper::recordDraw(
- Target* target, sk_sp<const GrGeometryProcessor> gp,
+ Target* target, sk_sp<const GrGeometryProcessor> gp, const GrPipeline* pipeline,
const GrPipeline::FixedDynamicState* fixedDynamicState) const {
- target->recordDraw(std::move(gp), fMesh, 1, fixedDynamicState, nullptr);
+ target->draw(std::move(gp), pipeline, fixedDynamicState, fMesh);
}
//////////////////////////////////////////////////////////////////////////////
@@ -74,32 +73,45 @@
//////////////////////////////////////////////////////////////////////////////
-GrPipeline::DynamicStateArrays* GrMeshDrawOp::Target::allocDynamicStateArrays(
- int numMeshes, int numPrimitiveProcessorTextures, bool allocScissors) {
- auto result = this->allocator()->make<GrPipeline::DynamicStateArrays>();
- if (allocScissors) {
- result->fScissorRects = this->allocator()->makeArray<SkIRect>(numMeshes);
- }
+GrPipeline::FixedDynamicState* GrMeshDrawOp::Target::allocFixedDynamicState(
+ const SkIRect& rect, int numPrimitiveProcessorTextures) {
+ auto result = this->pipelineArena()->make<GrPipeline::FixedDynamicState>(rect);
if (numPrimitiveProcessorTextures) {
result->fPrimitiveProcessorTextures =
- this->allocator()->makeArrayDefault<GrTextureProxy*>(
- numPrimitiveProcessorTextures * numMeshes);
+ this->allocPrimitiveProcessorTextureArray(numPrimitiveProcessorTextures);
}
return result;
}
-GrPipeline::FixedDynamicState* GrMeshDrawOp::Target::makeFixedDynamicState(
+GrPipeline::DynamicStateArrays* GrMeshDrawOp::Target::allocDynamicStateArrays(
+ int numMeshes, int numPrimitiveProcessorTextures, bool allocScissors) {
+ auto result = this->pipelineArena()->make<GrPipeline::DynamicStateArrays>();
+ if (allocScissors) {
+ result->fScissorRects = this->pipelineArena()->makeArray<SkIRect>(numMeshes);
+ }
+ if (numPrimitiveProcessorTextures) {
+ result->fPrimitiveProcessorTextures = this->allocPrimitiveProcessorTextureArray(
+ numPrimitiveProcessorTextures * numMeshes);
+ }
+ return result;
+}
+
+GrMeshDrawOp::Target::PipelineAndFixedDynamicState GrMeshDrawOp::Target::makePipeline(
+ uint32_t pipelineFlags, GrProcessorSet&& processorSet, GrAppliedClip&& clip,
int numPrimProcTextures) {
- const GrAppliedClip* clip = this->appliedClip();
- if ((clip && clip->scissorState().enabled()) || numPrimProcTextures) {
- const SkIRect& scissor = (clip) ? clip->scissorState().rect() : SkIRect::MakeEmpty();
- auto fixedDynamicState =
- this->allocator()->make<GrPipeline::FixedDynamicState>(scissor);
+ GrPipeline::InitArgs pipelineArgs;
+ pipelineArgs.fFlags = pipelineFlags;
+ pipelineArgs.fDstProxy = this->dstProxy();
+ pipelineArgs.fCaps = &this->caps();
+ pipelineArgs.fResourceProvider = this->resourceProvider();
+ GrPipeline::FixedDynamicState* fixedDynamicState = nullptr;
+ if (clip.scissorState().enabled() || numPrimProcTextures) {
+ fixedDynamicState = this->allocFixedDynamicState(clip.scissorState().rect());
if (numPrimProcTextures) {
fixedDynamicState->fPrimitiveProcessorTextures =
- this->allocator()->makeArrayDefault<GrTextureProxy*>(numPrimProcTextures);
+ this->allocPrimitiveProcessorTextureArray(numPrimProcTextures);
}
- return fixedDynamicState;
}
- return nullptr;
+ return {this->allocPipeline(pipelineArgs, std::move(processorSet), std::move(clip)),
+ fixedDynamicState};
}
diff --git a/src/gpu/ops/GrMeshDrawOp.h b/src/gpu/ops/GrMeshDrawOp.h
index f0c11a4..170fee0 100644
--- a/src/gpu/ops/GrMeshDrawOp.h
+++ b/src/gpu/ops/GrMeshDrawOp.h
@@ -39,8 +39,7 @@
int indicesPerRepetition, int repeatCount);
/** Called to issue draws to the GrMeshDrawOp::Target.*/
- void recordDraw(Target*, sk_sp<const GrGeometryProcessor>) const;
- void recordDraw(Target*, sk_sp<const GrGeometryProcessor>,
+ void recordDraw(Target*, sk_sp<const GrGeometryProcessor>, const GrPipeline*,
const GrPipeline::FixedDynamicState*) const;
void* vertices() const { return fVertices; }
@@ -73,6 +72,7 @@
private:
void onPrepare(GrOpFlushState* state) final;
+ void onExecute(GrOpFlushState* state, const SkRect& chainBounds) final;
virtual void onPrepareDraws(Target*) = 0;
typedef GrDrawOp INHERITED;
};
@@ -82,18 +82,18 @@
virtual ~Target() {}
/** Adds a draw of a mesh. */
- virtual void recordDraw(
- sk_sp<const GrGeometryProcessor>, const GrMesh[], int meshCnt,
- const GrPipeline::FixedDynamicState*, const GrPipeline::DynamicStateArrays*) = 0;
-
- /**
- * Helper for drawing GrMesh(es) with zero primProc textures and no dynamic state besides the
- * scissor clip.
- */
- void recordDraw(sk_sp<const GrGeometryProcessor> gp, const GrMesh meshes[], int meshCnt = 1) {
- static constexpr int kZeroPrimProcTextures = 0;
- auto fixedDynamicState = this->makeFixedDynamicState(kZeroPrimProcTextures);
- this->recordDraw(std::move(gp), meshes, meshCnt, fixedDynamicState, nullptr);
+ virtual void draw(sk_sp<const GrGeometryProcessor>,
+ const GrPipeline*,
+ const GrPipeline::FixedDynamicState*,
+ const GrPipeline::DynamicStateArrays*,
+ const GrMesh[],
+ int meshCount) = 0;
+ /** Helper for drawing a single GrMesh. */
+ void draw(sk_sp<const GrGeometryProcessor> gp,
+ const GrPipeline* pipeline,
+ const GrPipeline::FixedDynamicState* fixedDynamicState,
+ const GrMesh* mesh) {
+ this->draw(std::move(gp), pipeline, fixedDynamicState, nullptr, mesh, 1);
}
/**
@@ -135,21 +135,55 @@
virtual void putBackIndices(int indices) = 0;
virtual void putBackVertices(int vertices, size_t vertexStride) = 0;
- GrMesh* allocMesh(GrPrimitiveType primitiveType) {
- return this->allocator()->make<GrMesh>(primitiveType);
+ /**
+ * Allocate space for a pipeline. The target ensures this pipeline lifetime is at least
+ * as long as any deferred execution of draws added via draw().
+ * @tparam Args
+ * @param args
+ * @return
+ */
+ template <typename... Args>
+ GrPipeline* allocPipeline(Args&&... args) {
+ return this->pipelineArena()->make<GrPipeline>(std::forward<Args>(args)...);
}
- GrMesh* allocMeshes(int n) { return this->allocator()->makeArray<GrMesh>(n); }
+ GrMesh* allocMesh(GrPrimitiveType primitiveType) {
+ return this->pipelineArena()->make<GrMesh>(primitiveType);
+ }
+
+ GrMesh* allocMeshes(int n) { return this->pipelineArena()->makeArray<GrMesh>(n); }
+
+ GrPipeline::FixedDynamicState* allocFixedDynamicState(const SkIRect& rect,
+ int numPrimitiveProcessorTextures = 0);
GrPipeline::DynamicStateArrays* allocDynamicStateArrays(int numMeshes,
int numPrimitiveProcessorTextures,
bool allocScissors);
- GrPipeline::FixedDynamicState* makeFixedDynamicState(int numPrimitiveProcessorTextures);
+ GrTextureProxy** allocPrimitiveProcessorTextureArray(int n) {
+ SkASSERT(n > 0);
+ return this->pipelineArena()->makeArrayDefault<GrTextureProxy*>(n);
+ }
+
+ // Once we have C++17 structured bindings make this just be a tuple because then we can do:
+ // auto [pipeline, fixedDynamicState] = target->makePipeline(...);
+ // in addition to:
+ // std::tie(flushInfo.fPipeline, flushInfo.fFixedState) = target->makePipeline(...);
+ struct PipelineAndFixedDynamicState {
+ const GrPipeline* fPipeline;
+ GrPipeline::FixedDynamicState* fFixedDynamicState;
+ };
+
+ /**
+ * Helper that makes a pipeline targeting the op's render target that incorporates the op's
+ * GrAppliedClip and uses a fixed dynamic state.
+ */
+ PipelineAndFixedDynamicState makePipeline(uint32_t pipelineFlags, GrProcessorSet&&,
+ GrAppliedClip&&,
+ int numPrimitiveProcessorTextures = 0);
virtual GrRenderTargetProxy* proxy() const = 0;
- virtual const GrAppliedClip* appliedClip() = 0;
virtual GrAppliedClip detachAppliedClip() = 0;
virtual const GrXferProcessor::DstProxy& dstProxy() const = 0;
@@ -165,7 +199,7 @@
virtual GrDeferredUploadTarget* deferredUploadTarget() = 0;
private:
- virtual SkArenaAlloc* allocator() = 0;
+ virtual SkArenaAlloc* pipelineArena() = 0;
};
#endif
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index 3c44259..315455f 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -1289,11 +1289,8 @@
mesh->setIndexed(std::move(indexBuffer), fIndexCount, firstIndex, 0, fVertCount - 1,
GrPrimitiveRestart::kNo);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
@@ -1576,11 +1573,8 @@
mesh->setIndexed(std::move(indexBuffer), fIndexCount, firstIndex, 0, fVertCount - 1,
GrPrimitiveRestart::kNo);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
@@ -1812,11 +1806,8 @@
origin_centered_tri_strip(xMaxOffset, yMaxOffset),
invRadii);
}
- helper.recordDraw(target, std::move(gp));
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
@@ -2029,11 +2020,8 @@
origin_centered_tri_strip(innerRatioX + offsetDx,
innerRatioY + offsetDy));
}
- helper.recordDraw(target, std::move(gp));
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
@@ -2460,11 +2448,8 @@
mesh->setIndexed(std::move(indexBuffer), fIndexCount, firstIndex, 0, fVertCount - 1,
GrPrimitiveRestart::kNo);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
@@ -2731,11 +2716,8 @@
reciprocalRadii);
}
}
- helper.recordDraw(target, std::move(gp));
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index a90bfb9..c050142 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -134,11 +134,8 @@
iter.next();
}
}
- helper.recordDraw(target, std::move(gp));
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 8cb87d6..0d99501 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -589,16 +589,15 @@
}
}
+ static const uint32_t kPipelineFlags = 0;
+ auto pipe = target->makePipeline(kPipelineFlags, GrProcessorSet::MakeEmptySet(),
+ target->detachAppliedClip());
+
GrMesh* mesh = target->allocMesh(GrPrimitiveType::kTriangles);
mesh->setIndexed(std::move(indexBuffer), fIndexCount, firstIndex, 0, fVertCount - 1,
GrPrimitiveRestart::kNo);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, GrProcessorSet::MakeEmptySet());
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
index dcd5567..ad7fdf5 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
@@ -98,17 +98,6 @@
return result;
}
-void GrSimpleMeshDrawOpHelper::executeDrawsAndUploads(
- const GrOp* op, GrOpFlushState* flushState, const SkRect& chainBounds) {
- if (fProcessors) {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- op, chainBounds, std::move(*fProcessors), fPipelineFlags);
- } else {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- op, chainBounds, GrProcessorSet::MakeEmptySet(), fPipelineFlags);
- }
-}
-
#ifdef SK_DEBUG
SkString GrSimpleMeshDrawOpHelper::dumpInfo() const {
const GrProcessorSet& processors = fProcessors ? *fProcessors : GrProcessorSet::EmptySet();
@@ -133,6 +122,42 @@
}
#endif
+GrPipeline::InitArgs GrSimpleMeshDrawOpHelper::pipelineInitArgs(
+ GrMeshDrawOp::Target* target) const {
+ GrPipeline::InitArgs args;
+ args.fFlags = this->pipelineFlags();
+ args.fDstProxy = target->dstProxy();
+ args.fCaps = &target->caps();
+ args.fResourceProvider = target->resourceProvider();
+ return args;
+}
+
+auto GrSimpleMeshDrawOpHelper::internalMakePipeline(GrMeshDrawOp::Target* target,
+ const GrPipeline::InitArgs& args,
+ int numPrimitiveProcessorProxies)
+ -> PipelineAndFixedDynamicState {
+ // A caller really should only call this once as the processor set and applied clip get
+ // moved into the GrPipeline.
+ SkASSERT(!fMadePipeline);
+ SkDEBUGCODE(fMadePipeline = true);
+ auto clip = target->detachAppliedClip();
+ GrPipeline::FixedDynamicState* fixedDynamicState = nullptr;
+ if (clip.scissorState().enabled() || numPrimitiveProcessorProxies) {
+ fixedDynamicState = target->allocFixedDynamicState(clip.scissorState().rect());
+ if (numPrimitiveProcessorProxies) {
+ fixedDynamicState->fPrimitiveProcessorTextures =
+ target->allocPrimitiveProcessorTextureArray(numPrimitiveProcessorProxies);
+ }
+ }
+ if (fProcessors) {
+ return {target->allocPipeline(args, std::move(*fProcessors), std::move(clip)),
+ fixedDynamicState};
+ } else {
+ return {target->allocPipeline(args, GrProcessorSet::MakeEmptySet(), std::move(clip)),
+ fixedDynamicState};
+ }
+}
+
GrSimpleMeshDrawOpHelperWithStencil::GrSimpleMeshDrawOpHelperWithStencil(
const MakeArgs& args, GrAAType aaType, const GrUserStencilSettings* stencilSettings,
Flags flags)
@@ -154,15 +179,12 @@
fStencilSettings == that.fStencilSettings;
}
-void GrSimpleMeshDrawOpHelperWithStencil::executeDrawsAndUploads(
- const GrOp* op, GrOpFlushState* flushState, const SkRect& chainBounds) {
- if (fProcessors) {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- op, chainBounds, std::move(*fProcessors), fPipelineFlags, fStencilSettings);
- } else {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- op, chainBounds, GrProcessorSet::MakeEmptySet(), fPipelineFlags, fStencilSettings);
- }
+auto GrSimpleMeshDrawOpHelperWithStencil::makePipeline(GrMeshDrawOp::Target* target,
+ int numPrimitiveProcessorTextures)
+ -> PipelineAndFixedDynamicState {
+ auto args = INHERITED::pipelineInitArgs(target);
+ args.fUserStencil = fStencilSettings;
+ return this->internalMakePipeline(target, args, numPrimitiveProcessorTextures);
}
#ifdef SK_DEBUG
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
index 8c37b48..66b9b4c 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
@@ -92,6 +92,14 @@
bool compatibleWithAlphaAsCoverage() const { return fCompatibleWithAlphaAsCoveage; }
+ using PipelineAndFixedDynamicState = GrOpFlushState::PipelineAndFixedDynamicState;
+ /** Makes a pipeline that consumes the processor set and the op's applied clip. */
+ PipelineAndFixedDynamicState makePipeline(GrMeshDrawOp::Target* target,
+ int numPrimitiveProcessorTextures = 0) {
+ return this->internalMakePipeline(target, this->pipelineInitArgs(target),
+ numPrimitiveProcessorTextures);
+ }
+
struct MakeArgs {
private:
MakeArgs() = default;
@@ -116,11 +124,16 @@
fAAType = static_cast<unsigned>(aaType);
}
- void executeDrawsAndUploads(const GrOp*, GrOpFlushState*, const SkRect& chainBounds);
-
protected:
uint32_t pipelineFlags() const { return fPipelineFlags; }
+ GrPipeline::InitArgs pipelineInitArgs(GrMeshDrawOp::Target* target) const;
+
+ PipelineAndFixedDynamicState internalMakePipeline(GrMeshDrawOp::Target*,
+ const GrPipeline::InitArgs&,
+ int numPrimitiveProcessorTextures);
+
+private:
GrProcessorSet* fProcessors;
unsigned fPipelineFlags : 8;
unsigned fAAType : 2;
@@ -139,6 +152,7 @@
public:
using MakeArgs = GrSimpleMeshDrawOpHelper::MakeArgs;
using Flags = GrSimpleMeshDrawOpHelper::Flags;
+ using PipelineAndFixedDynamicState = GrOpFlushState::PipelineAndFixedDynamicState;
using GrSimpleMeshDrawOpHelper::visitProxies;
@@ -166,7 +180,8 @@
const SkRect& thisBounds, const SkRect& thatBounds,
bool noneAACompatibleWithCoverage = false) const;
- void executeDrawsAndUploads(const GrOp*, GrOpFlushState*, const SkRect& chainBounds);
+ PipelineAndFixedDynamicState makePipeline(GrMeshDrawOp::Target*,
+ int numPrimitiveProcessorTextures = 0);
#ifdef SK_DEBUG
SkString dumpInfo() const;
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 25791aa..bb55520 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -308,6 +308,7 @@
sk_sp<const GrBuffer> fVertexBuffer;
sk_sp<const GrBuffer> fIndexBuffer;
sk_sp<GrGeometryProcessor> fGeometryProcessor;
+ const GrPipeline* fPipeline;
GrPipeline::FixedDynamicState* fFixedDynamicState;
int fVertexOffset;
int fInstancesToFlush;
@@ -319,14 +320,17 @@
static constexpr int kMaxTextures = GrDistanceFieldPathGeoProc::kMaxTextures;
GR_STATIC_ASSERT(GrBitmapTextGeoProc::kMaxTextures == kMaxTextures);
- FlushInfo flushInfo;
- flushInfo.fFixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
+ auto pipe = fHelper.makePipeline(target, kMaxTextures);
int numActiveProxies = fAtlas->numActivePages();
const auto proxies = fAtlas->getProxies();
for (int i = 0; i < numActiveProxies; ++i) {
- flushInfo.fFixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
+ pipe.fFixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
}
+ FlushInfo flushInfo;
+ flushInfo.fPipeline = pipe.fPipeline;
+ flushInfo.fFixedDynamicState = pipe.fFixedDynamicState;
+
// Setup GrGeometryProcessor
const SkMatrix& ctm = fShapes[0].fViewMatrix;
if (fUsesDistanceField) {
@@ -794,17 +798,13 @@
mesh->setIndexedPatterned(flushInfo->fIndexBuffer, kIndicesPerQuad, kVerticesPerQuad,
flushInfo->fInstancesToFlush, maxInstancesPerDraw);
mesh->setVertexData(flushInfo->fVertexBuffer, flushInfo->fVertexOffset);
- target->recordDraw(
- flushInfo->fGeometryProcessor, mesh, 1, flushInfo->fFixedDynamicState, nullptr);
+ target->draw(flushInfo->fGeometryProcessor, flushInfo->fPipeline,
+ flushInfo->fFixedDynamicState, mesh);
flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
flushInfo->fInstancesToFlush = 0;
}
}
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
- }
-
const SkPMColor4f& color() const { return fShapes[0].fColor; }
bool usesDistanceField() const { return fUsesDistanceField; }
diff --git a/src/gpu/ops/GrStrokeRectOp.cpp b/src/gpu/ops/GrStrokeRectOp.cpp
index 71c5aec..e50f918 100644
--- a/src/gpu/ops/GrStrokeRectOp.cpp
+++ b/src/gpu/ops/GrStrokeRectOp.cpp
@@ -217,11 +217,8 @@
GrMesh* mesh = target->allocMesh(primType);
mesh->setNonIndexedNonInstanced(vertexCount);
mesh->setVertexData(std::move(vertexBuffer), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
// TODO: override onCombineIfPossible
@@ -415,7 +412,6 @@
private:
void onPrepareDraws(Target*) override;
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
static const int kMiterIndexCnt = 3 * 24;
static const int kMiterVertexCnt = 16;
@@ -504,11 +500,8 @@
info.fDegenerate,
fHelper.compatibleWithAlphaAsCoverage());
}
- helper.recordDraw(target, std::move(gp));
-}
-
-void AAStrokeRectOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState);
}
sk_sp<const GrGpuBuffer> AAStrokeRectOp::GetIndexBuffer(GrResourceProvider* resourceProvider,
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index e619f19..dc3f59f 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -363,11 +363,8 @@
: GrPrimitiveType::kTriangles);
mesh->setNonIndexedNonInstanced(count);
mesh->setVertexData(std::move(vb), firstVertex);
- target->recordDraw(std::move(gp), mesh);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- fHelper.executeDrawsAndUploads(this, flushState, chainBounds);
+ auto pipe = fHelper.makePipeline(target);
+ target->draw(std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState, mesh);
}
Helper fHelper;
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index eb9ccee..5cf35ec 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -453,17 +453,28 @@
textureType, config, samplerState, extraSamplerKey,
std::move(fTextureColorSpaceXform));
+ GrPipeline::InitArgs args;
+ args.fCaps = &target->caps();
+ args.fResourceProvider = target->resourceProvider();
+ args.fFlags = 0;
+ if (aaType == GrAAType::kMSAA) {
+ args.fFlags |= GrPipeline::kHWAntialias_Flag;
+ }
+
+ auto clip = target->detachAppliedClip();
// We'll use a dynamic state array for the GP textures when there are multiple ops.
// Otherwise, we use fixed dynamic state to specify the single op's proxy.
GrPipeline::DynamicStateArrays* dynamicStateArrays = nullptr;
GrPipeline::FixedDynamicState* fixedDynamicState;
if (numProxies > 1) {
dynamicStateArrays = target->allocDynamicStateArrays(numProxies, 1, false);
- fixedDynamicState = target->makeFixedDynamicState(0);
+ fixedDynamicState = target->allocFixedDynamicState(clip.scissorState().rect(), 0);
} else {
- fixedDynamicState = target->makeFixedDynamicState(1);
+ fixedDynamicState = target->allocFixedDynamicState(clip.scissorState().rect(), 1);
fixedDynamicState->fPrimitiveProcessorTextures[0] = fProxies[0].fProxy;
}
+ const auto* pipeline =
+ target->allocPipeline(args, GrProcessorSet::MakeEmptySet(), std::move(clip));
size_t vertexSize = gp->vertexStride();
@@ -514,16 +525,8 @@
}
SkASSERT(!numQuadVerticesLeft);
SkASSERT(!numAllocatedVertices);
- target->recordDraw(
- std::move(gp), meshes, numProxies, fixedDynamicState, dynamicStateArrays);
- }
-
- void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- auto pipelineFlags = (GrAAType::kMSAA == this->aaType())
- ? GrPipeline::kHWAntialias_Flag
- : 0;
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, GrProcessorSet::MakeEmptySet(), pipelineFlags);
+ target->draw(std::move(gp), pipeline, fixedDynamicState, dynamicStateArrays, meshes,
+ numProxies);
}
CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override {