From cbfe91d82500f4ae8c3ff7bd74b3021a4b89fd84 Mon Sep 17 00:00:00 2001 From: joshualitt Date: Tue, 19 May 2015 06:49:32 -0700 Subject: [PATCH] Preliminary attempt to remove batch tracker BUG=skia: Review URL: https://codereview.chromium.org/1139723004 --- gm/beziereffects.cpp | 4 +- gm/convexpolyeffect.cpp | 3 +- src/gpu/GrAAConvexPathRenderer.cpp | 81 +++----- src/gpu/GrAADistanceFieldPathRenderer.cpp | 21 +- src/gpu/GrAAHairLinePathRenderer.cpp | 29 +-- src/gpu/GrAARectRenderer.cpp | 40 ++-- src/gpu/GrAtlasTextContext.cpp | 30 +-- src/gpu/GrBatchTarget.h | 6 - src/gpu/GrContext.cpp | 33 +-- src/gpu/GrDefaultGeoProcFactory.cpp | 123 ++++++------ src/gpu/GrDefaultGeoProcFactory.h | 2 + src/gpu/GrDefaultPathRenderer.cpp | 13 +- src/gpu/GrGeometryProcessor.h | 32 +-- src/gpu/GrOvalRenderer.cpp | 221 ++++++++------------- src/gpu/GrPathProcessor.cpp | 19 +- src/gpu/GrPathProcessor.h | 32 --- src/gpu/GrRectBatch.cpp | 28 ++- src/gpu/GrTessellatingPathRenderer.cpp | 5 +- src/gpu/GrTestBatch.h | 10 - src/gpu/effects/GrBezierEffect.cpp | 130 +++++------- src/gpu/effects/GrBezierEffect.h | 33 +-- src/gpu/effects/GrBitmapTextGeoProc.cpp | 50 ++--- src/gpu/effects/GrBitmapTextGeoProc.h | 15 +- src/gpu/effects/GrDashingEffect.cpp | 136 ++++++------- src/gpu/effects/GrDistanceFieldGeoProc.cpp | 131 +++++------- src/gpu/effects/GrDistanceFieldGeoProc.h | 44 ++-- src/gpu/gl/GrGLPrimitiveProcessor.cpp | 32 +-- src/gpu/gl/GrGLPrimitiveProcessor.h | 11 +- 28 files changed, 506 insertions(+), 808 deletions(-) diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp index 5070eeaf29..384889f0c5 100644 --- a/gm/beziereffects.cpp +++ b/gm/beziereffects.cpp @@ -310,7 +310,7 @@ protected: } GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)edgeType; gp.reset(GrConicEffect::Create(color, SkMatrix::I(), et, - *tt.target()->caps(), SkMatrix::I())); + *tt.target()->caps(), SkMatrix::I(), false)); if (!gp) { continue; } @@ -550,7 +550,7 @@ protected: } GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)edgeType; gp.reset(GrQuadEffect::Create(color, SkMatrix::I(), et, - *tt.target()->caps(), SkMatrix::I())); + *tt.target()->caps(), SkMatrix::I(), false)); if (!gp) { continue; } diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp index 9c6741aac6..b27f7c2039 100644 --- a/gm/convexpolyeffect.cpp +++ b/gm/convexpolyeffect.cpp @@ -158,7 +158,8 @@ protected: static const GrColor color = 0xff000000; SkAutoTUnref gp( - GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, color)); + GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, color, + false, false)); SkScalar y = 0; for (SkTLList::Iter iter(fPaths, SkTLList::Iter::kHead_IterStart); diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp index 0d909b1dc6..1b7efefd07 100644 --- a/src/gpu/GrAAConvexPathRenderer.cpp +++ b/src/gpu/GrAAConvexPathRenderer.cpp @@ -525,8 +525,9 @@ static void create_vertices(const SegmentArray& segments, class QuadEdgeEffect : public GrGeometryProcessor { public: - static GrGeometryProcessor* Create(GrColor color, const SkMatrix& localMatrix) { - return SkNEW_ARGS(QuadEdgeEffect, (color, localMatrix)); + static GrGeometryProcessor* Create(GrColor color, const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(QuadEdgeEffect, (color, localMatrix, usesLocalCoords)); } virtual ~QuadEdgeEffect() {} @@ -536,7 +537,9 @@ public: const Attribute* inPosition() const { return fInPosition; } const Attribute* inQuadEdge() const { return fInQuadEdge; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } class GLProcessor : public GrGLGeometryProcessor { public: @@ -556,11 +559,10 @@ public: args.fPB->addVarying("QuadEdge", &v); vsBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.inQuadEdge()->fName); - const BatchTracker& local = args.fBT.cast(); - // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + if (!qe.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, qe.inPosition()->fName); @@ -598,22 +600,22 @@ public: const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const BatchTracker& local = bt.cast(); const QuadEdgeEffect& qee = gp.cast(); - uint32_t key = local.fInputColorType << 16; - key |= local.fUsesLocalCoords && qee.localMatrix().hasPerspective() ? 0x1 : 0x0; + uint32_t key = 0; + key |= qee.usesLocalCoords() && qee.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= qee.colorIgnored() ? 0x2 : 0x0; b->add32(key); } virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { - const BatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const QuadEdgeEffect& qe = gp.cast(); + if (qe.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(qe.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = qe.color(); } } @@ -642,31 +644,21 @@ public: return SkNEW_ARGS(GLProcessor, (*this, bt)); } - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override { - BatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; - } - private: - QuadEdgeEffect(GrColor color, const SkMatrix& localMatrix) + QuadEdgeEffect(GrColor color, const SkMatrix& localMatrix, bool usesLocalCoords) : fColor(color) - , fLocalMatrix(localMatrix) { + , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInQuadEdge = &this->addVertexAttrib(Attribute("inQuadEdge", kVec4f_GrVertexAttribType)); } - struct BatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; - }; - const Attribute* fInPosition; const Attribute* fInQuadEdge; GrColor fColor; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -682,7 +674,8 @@ GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random, // Doesn't work without derivative instructions. return caps.shaderCaps()->shaderDerivativeSupport() ? QuadEdgeEffect::Create(GrRandomColor(random), - GrTest::TestMatrix(random)) : NULL; + GrTest::TestMatrix(random), + random->nextBool()) : NULL; } /////////////////////////////////////////////////////////////////////////////// @@ -732,13 +725,16 @@ static void extract_verts(const GrAAConvexTessellator& tess, } static const GrGeometryProcessor* create_fill_gp(bool tweakAlphaForCoverage, - const SkMatrix& localMatrix) { + const SkMatrix& localMatrix, + bool usesLocalCoords, + bool coverageIgnored) { uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType; if (!tweakAlphaForCoverage) { flags |= GrDefaultGeoProcFactory::kCoverage_GPType; } - return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, SkMatrix::I(), localMatrix); + return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored, + SkMatrix::I(), localMatrix); } class AAConvexPathBatch : public GrBatch { @@ -791,18 +787,12 @@ public: // Setup GrGeometryProcessor SkAutoTUnref gp( - create_fill_gp(canTweakAlphaForCoverage, invert)); + create_fill_gp(canTweakAlphaForCoverage, invert, + this->usesLocalCoords(), + this->coverageIgnored())); batchTarget->initDraw(gp, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - size_t vertexStride = gp->getVertexStride(); SkASSERT(canTweakAlphaForCoverage ? @@ -870,19 +860,11 @@ public: } // Setup GrGeometryProcessor - SkAutoTUnref quadProcessor(QuadEdgeEffect::Create(this->color(), - invert)); + SkAutoTUnref quadProcessor( + QuadEdgeEffect::Create(this->color(), invert, this->usesLocalCoords())); batchTarget->initDraw(quadProcessor, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - quadProcessor->initBatchTracker(batchTarget->currentBatchTracker(), init); - // TODO generate all segments for all paths and use one vertex buffer for (int i = 0; i < instanceCount; i++) { Geometry& args = fGeoData[i]; @@ -991,6 +973,7 @@ private: 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; } struct BatchTracker { GrColor fColor; diff --git a/src/gpu/GrAADistanceFieldPathRenderer.cpp b/src/gpu/GrAADistanceFieldPathRenderer.cpp index b6a9797bc3..21fbcb37fb 100755 --- a/src/gpu/GrAADistanceFieldPathRenderer.cpp +++ b/src/gpu/GrAADistanceFieldPathRenderer.cpp @@ -197,9 +197,10 @@ public: this->viewMatrix(), atlas->getTexture(), params, - flags)); + flags, + this->usesLocalCoords())); - this->initDraw(batchTarget, dfProcessor, pipeline); + batchTarget->initDraw(dfProcessor, pipeline); FlushInfo flushInfo; @@ -414,7 +415,7 @@ private: &atlasLocation); if (!success) { this->flush(batchTarget, flushInfo); - this->initDraw(batchTarget, dfProcessor, pipeline); + batchTarget->initDraw(dfProcessor, pipeline); SkDEBUGCODE(success =) atlas->addToAtlas(&id, batchTarget, width, height, dfStorage.get(), &atlasLocation); @@ -491,20 +492,6 @@ private: vertexStride); } - void initDraw(GrBatchTarget* batchTarget, - const GrGeometryProcessor* dfProcessor, - const GrPipeline* pipeline) { - batchTarget->initDraw(dfProcessor, pipeline); - - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - dfProcessor->initBatchTracker(batchTarget->currentBatchTracker(), init); - } - void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) { GrVertices vertices; int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads(); diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp index dc035fc772..6dcf063974 100644 --- a/src/gpu/GrAAHairLinePathRenderer.cpp +++ b/src/gpu/GrAAHairLinePathRenderer.cpp @@ -774,6 +774,7 @@ private: 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; } struct BatchTracker { GrColor fColor; @@ -815,6 +816,8 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel SkAutoTUnref lineGP( GrDefaultGeoProcFactory::Create(gpFlags, this->color(), + this->usesLocalCoords(), + this->coverageIgnored(), *geometryProcessorViewM, *geometryProcessorLocalM, this->coverage())); @@ -825,6 +828,7 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel kHairlineAA_GrProcessorEdgeType, batchTarget->caps(), *geometryProcessorLocalM, + this->usesLocalCoords(), this->coverage())); SkAutoTUnref conicGP( @@ -833,6 +837,7 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel kHairlineAA_GrProcessorEdgeType, batchTarget->caps(), *geometryProcessorLocalM, + this->usesLocalCoords(), this->coverage())); // This is hand inlined for maximum performance. @@ -859,14 +864,6 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel ref_lines_index_buffer(batchTarget->resourceProvider())); batchTarget->initDraw(lineGP, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - lineGP->initBatchTracker(batchTarget->currentBatchTracker(), init); - const GrVertexBuffer* vertexBuffer; int firstVertex; @@ -929,14 +926,6 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel if (quadCount > 0) { batchTarget->initDraw(quadGP, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - quadGP->initBatchTracker(batchTarget->currentBatchTracker(), init); - { GrVertices verts; verts.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer, @@ -950,14 +939,6 @@ void AAHairlineBatch::generateGeometry(GrBatchTarget* batchTarget, const GrPipel if (conicCount > 0) { batchTarget->initDraw(conicGP, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - conicGP->initBatchTracker(batchTarget->currentBatchTracker(), init); - { GrVertices verts; verts.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer, diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp index a4656a7c3e..6b8abc38fb 100644 --- a/src/gpu/GrAARectRenderer.cpp +++ b/src/gpu/GrAARectRenderer.cpp @@ -31,14 +31,18 @@ static void set_inset_fan(SkPoint* pts, size_t stride, } static const GrGeometryProcessor* create_fill_rect_gp(bool tweakAlphaForCoverage, - const SkMatrix& localMatrix) { + const SkMatrix& localMatrix, + bool usesLocalCoords, + bool coverageIgnored) { uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType; const GrGeometryProcessor* gp; if (tweakAlphaForCoverage) { - gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, SkMatrix::I(), localMatrix); + gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored, + SkMatrix::I(), localMatrix); } else { flags |= GrDefaultGeoProcFactory::kCoverage_GPType; - gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, SkMatrix::I(), localMatrix); + gp = GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored, + SkMatrix::I(), localMatrix); } return gp; } @@ -95,20 +99,12 @@ public: } SkAutoTUnref gp(create_fill_rect_gp(canTweakAlphaForCoverage, - localMatrix)); + localMatrix, + this->usesLocalCoords(), + this->coverageIgnored())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - size_t vertexStride = gp->getVertexStride(); SkASSERT(canTweakAlphaForCoverage ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) : @@ -176,6 +172,7 @@ private: bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; } bool colorIgnored() const { return fBatch.fColorIgnored; } const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } bool onCombineIfPossible(GrBatch* t) override { AAFillRectBatch* that = t->cast(); @@ -453,20 +450,12 @@ public: } SkAutoTUnref gp(create_fill_rect_gp(canTweakAlphaForCoverage, - localMatrix)); + localMatrix, + this->usesLocalCoords(), + this->coverageIgnored())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - size_t vertexStride = gp->getVertexStride(); SkASSERT(canTweakAlphaForCoverage ? @@ -626,6 +615,7 @@ private: bool colorIgnored() const { return fBatch.fColorIgnored; } const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; } bool miterStroke() const { return fBatch.fMiterStroke; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } bool onCombineIfPossible(GrBatch* t) override { AAStrokeRectBatch* that = t->cast(); diff --git a/src/gpu/GrAtlasTextContext.cpp b/src/gpu/GrAtlasTextContext.cpp index dfb07ed820..f2307574fb 100644 --- a/src/gpu/GrAtlasTextContext.cpp +++ b/src/gpu/GrAtlasTextContext.cpp @@ -1537,7 +1537,8 @@ public: texture, params, fMaskFormat, - localMatrix)); + localMatrix, + this->usesLocalCoords())); } FlushInfo flushInfo; @@ -1547,7 +1548,7 @@ public: get_vertex_stride_df(fMaskFormat, fUseLCDText) : get_vertex_stride(fMaskFormat))); - this->initDraw(batchTarget, gp, pipeline); + batchTarget->initDraw(gp, pipeline); int glyphCount = this->numGlyphs(); int instanceCount = fInstanceCount; @@ -1657,7 +1658,7 @@ public: if (!fFontCache->hasGlyph(glyph) && !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) { this->flush(batchTarget, &flushInfo); - this->initDraw(batchTarget, gp, pipeline); + batchTarget->initDraw(gp, pipeline); brokenRun = glyphIdx > 0; SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget, @@ -1849,20 +1850,6 @@ private: } } - void initDraw(GrBatchTarget* batchTarget, - const GrGeometryProcessor* gp, - const GrPipeline* pipeline) { - batchTarget->initDraw(gp, pipeline); - - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - } - void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) { GrVertices vertices; int maxGlyphsPerDraw = flushInfo->fIndexBuffer->maxQuads(); @@ -1992,7 +1979,8 @@ private: texture, params, widthAdjust, - flags); + flags, + this->usesLocalCoords()); } else { flags |= kColorAttr_DistanceFieldEffectFlag; #ifdef SK_GAMMA_APPLY_TO_A8 @@ -2003,13 +1991,15 @@ private: texture, params, correction, - flags); + flags, + this->usesLocalCoords()); #else return GrDistanceFieldA8TextGeoProc::Create(color, viewMatrix, texture, params, - flags); + flags, + this->usesLocalCoords()); #endif } diff --git a/src/gpu/GrBatchTarget.h b/src/gpu/GrBatchTarget.h index f317f3046e..61f12d8169 100644 --- a/src/gpu/GrBatchTarget.h +++ b/src/gpu/GrBatchTarget.h @@ -104,12 +104,6 @@ public: fInlineUploads.reset(); } - // TODO This goes away when everything uses batch - GrBatchTracker* currentBatchTracker() { - SkASSERT(!fFlushBuffer.empty()); - return &fFlushBuffer.back().fBatchTracker; - } - const GrDrawTargetCaps& caps() const { return *fGpu->caps(); } GrResourceProvider* resourceProvider() const { return fGpu->getContext()->resourceProvider(); } diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 1863b7f962..1609efb440 100755 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -438,21 +438,13 @@ public: SkAutoTUnref gp( GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, this->color(), + this->usesLocalCoords(), + this->coverageIgnored(), this->viewMatrix(), SkMatrix::I())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(GrDefaultGeoProcFactory::PositionAttr)); @@ -549,6 +541,7 @@ private: bool colorIgnored() const { return fBatch.fColorIgnored; } const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; } bool hairline() const { return fBatch.fHairline; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } bool onCombineIfPossible(GrBatch* t) override { // StrokeRectBatch* that = t->cast(); @@ -711,7 +704,8 @@ static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords, int* colorOffset, int* texOffset, GrColor color, - const SkMatrix& viewMatrix) { + const SkMatrix& viewMatrix, + bool coverageIgnored) { *texOffset = -1; *colorOffset = -1; uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType; @@ -727,7 +721,8 @@ static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords, *colorOffset = sizeof(SkPoint); flags |= GrDefaultGeoProcFactory::kColor_GPType; } - return GrDefaultGeoProcFactory::Create(flags, color, viewMatrix, SkMatrix::I()); + return GrDefaultGeoProcFactory::Create(flags, color, hasLocalCoords, coverageIgnored, + viewMatrix, SkMatrix::I()); } class DrawVerticesBatch : public GrBatch { @@ -785,20 +780,11 @@ public: int colorOffset = -1, texOffset = -1; SkAutoTUnref gp( set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset, - &texOffset, this->color(), this->viewMatrix())); + &texOffset, this->color(), this->viewMatrix(), + this->coverageIgnored())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(SkPoint) + (this->hasLocalCoords() ? sizeof(SkPoint) : 0) @@ -923,6 +909,7 @@ private: bool hasLocalCoords() const { return fBatch.fHasLocalCoords; } int vertexCount() const { return fBatch.fVertexCount; } int indexCount() const { return fBatch.fIndexCount; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } bool onCombineIfPossible(GrBatch* t) override { DrawVerticesBatch* that = t->cast(); diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp index 6dbf71e0d8..55b3a1f9ef 100644 --- a/src/gpu/GrDefaultGeoProcFactory.cpp +++ b/src/gpu/GrDefaultGeoProcFactory.cpp @@ -24,12 +24,16 @@ public: GrColor color, const SkMatrix& viewMatrix, const SkMatrix& localMatrix, + bool usesLocalCoords, + bool coverageIgnored, uint8_t coverage) { return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags, color, viewMatrix, localMatrix, - coverage)); + coverage, + usesLocalCoords, + coverageIgnored)); } const char* name() const override { return "DefaultGeometryProcessor"; } @@ -39,30 +43,14 @@ public: const Attribute* inLocalCoords() const { return fInLocalCoords; } const Attribute* inCoverage() const { return fInCoverage; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + bool hasVertexColor() const { return SkToBool(fInColor); } const SkMatrix& viewMatrix() const { return fViewMatrix; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } uint8_t coverage() const { return fCoverage; } - - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override { - BatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, - SkToBool(fInColor)); - - bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored; - bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage(); - if (init.fCoverageIgnored) { - local->fInputCoverageType = kIgnored_GrGPInput; - } else if (covIsSolidWhite) { - local->fInputCoverageType = kAllOnes_GrGPInput; - } else if (hasVertexCoverage) { - SkASSERT(fInCoverage); - local->fInputCoverageType = kAttribute_GrGPInput; - } else { - local->fInputCoverageType = kUniform_GrGPInput; - local->fCoverage = this->coverage(); - } - local->fUsesLocalCoords = init.fUsesLocalCoords; - } + bool coverageIgnored() const { return fCoverageIgnored; } + bool hasVertexCoverage() const { return SkToBool(fInCoverage); } class GLProcessor : public GrGLGeometryProcessor { public: @@ -74,14 +62,19 @@ public: GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder(); GrGLFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); - const BatchTracker& local = args.fBT.cast(); // emit attributes vsBuilder->emitAttributes(gp); // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, gp.inColor(), - &fColorUniform); + if (!gp.colorIgnored()) { + if (gp.hasVertexColor()) { + pb->addPassThroughAttribute(gp.inColor(), args.fOutputColor); + } else { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } + } + // Setup position this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix()); @@ -96,21 +89,22 @@ public: } // Setup coverage as pass through - if (kUniform_GrGPInput == local.fInputCoverageType) { - const char* fragCoverage; - fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, - kFloat_GrSLType, - kDefault_GrSLPrecision, - "Coverage", - &fragCoverage); - fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage); - } else if (kAttribute_GrGPInput == local.fInputCoverageType) { - SkASSERT(gp.inCoverage()); - fs->codeAppendf("float alpha = 1.0;"); - args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); - fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); - } else if (kAllOnes_GrGPInput == local.fInputCoverageType) { - fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); + if (!gp.coverageIgnored()) { + if (gp.hasVertexCoverage()) { + fs->codeAppendf("float alpha = 1.0;"); + args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); + fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); + } else if (gp.coverage() == 0xff) { + fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); + } else { + const char* fragCoverage; + fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, + kFloat_GrSLType, + kDefault_GrSLPrecision, + "Coverage", + &fragCoverage); + fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage); + } } } @@ -119,10 +113,13 @@ public: const GrGLSLCaps&, GrProcessorKeyBuilder* b) { const DefaultGeoProc& def = gp.cast(); - const BatchTracker& local = bt.cast(); uint32_t key = def.fFlags; - key |= local.fInputColorType << 8 | local.fInputCoverageType << 16; - key |= local.fUsesLocalCoords && def.localMatrix().hasPerspective() ? 0x1 << 24 : 0x0; + key |= def.colorIgnored() << 8; + key |= def.coverageIgnored() << 9; + key |= def.hasVertexColor() << 10; + key |= def.hasVertexCoverage() << 11; + key |= def.coverage() == 0xff ? 0x1 << 12 : 0; + key |= def.usesLocalCoords() && def.localMatrix().hasPerspective() ? 0x1 << 24 : 0x0; key |= ComputePosKey(def.viewMatrix()) << 25; b->add32(key); } @@ -133,16 +130,16 @@ public: const DefaultGeoProc& dgp = gp.cast(); this->setUniformViewMatrix(pdman, dgp.viewMatrix()); - const BatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (dgp.color() != fColor && !dgp.hasVertexColor()) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dgp.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dgp.color(); } - if (kUniform_GrGPInput == local.fInputCoverageType && local.fCoverage != fCoverage) { - pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCoverage)); - fCoverage = local.fCoverage; + + if (dgp.coverage() != fCoverage && !dgp.hasVertexCoverage()) { + pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.coverage())); + fCoverage = dgp.coverage(); } } @@ -178,7 +175,9 @@ private: GrColor color, const SkMatrix& viewMatrix, const SkMatrix& localMatrix, - uint8_t coverage) + uint8_t coverage, + bool usesLocalCoords, + bool coverageIgnored) : fInPosition(NULL) , fInColor(NULL) , fInLocalCoords(NULL) @@ -187,7 +186,9 @@ private: , fViewMatrix(viewMatrix) , fLocalMatrix(localMatrix) , fCoverage(coverage) - , fFlags(gpTypeFlags) { + , fFlags(gpTypeFlags) + , fUsesLocalCoords(usesLocalCoords) + , fCoverageIgnored(coverageIgnored) { this->initClassID(); bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType); bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType); @@ -198,7 +199,7 @@ private: } if (hasLocalCoord) { fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord", - kVec2f_GrVertexAttribType)); + kVec2f_GrVertexAttribType)); this->setHasLocalCoords(); } if (hasCoverage) { @@ -207,14 +208,6 @@ private: } } - struct BatchTracker { - GrGPInput fInputColorType; - GrGPInput fInputCoverageType; - GrColor fColor; - GrColor fCoverage; - bool fUsesLocalCoords; - }; - const Attribute* fInPosition; const Attribute* fInColor; const Attribute* fInLocalCoords; @@ -224,6 +217,8 @@ private: SkMatrix fLocalMatrix; uint8_t fCoverage; uint32_t fFlags; + bool fUsesLocalCoords; + bool fCoverageIgnored; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -251,11 +246,15 @@ GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, GrRandomColor(random), GrTest::TestMatrix(random), GrTest::TestMatrix(random), + random->nextBool(), + random->nextBool(), GrRandomCoverage(random)); } const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags, GrColor color, + bool usesLocalCoords, + bool coverageIgnored, const SkMatrix& viewMatrix, const SkMatrix& localMatrix, uint8_t coverage) { @@ -263,5 +262,7 @@ const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags, color, viewMatrix, localMatrix, + usesLocalCoords, + coverageIgnored, coverage); } diff --git a/src/gpu/GrDefaultGeoProcFactory.h b/src/gpu/GrDefaultGeoProcFactory.h index aee16fd027..3722a320ce 100644 --- a/src/gpu/GrDefaultGeoProcFactory.h +++ b/src/gpu/GrDefaultGeoProcFactory.h @@ -83,6 +83,8 @@ public: // TODO clean this up static const GrGeometryProcessor* Create(uint32_t gpTypeFlags, GrColor, + bool usesLocalCoords, + bool coverageIgnored, const SkMatrix& viewMatrix = SkMatrix::I(), const SkMatrix& localMatrix = SkMatrix::I(), uint8_t coverage = 0xff); diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp index 1be5ce7939..7659847ecc 100644 --- a/src/gpu/GrDefaultPathRenderer.cpp +++ b/src/gpu/GrDefaultPathRenderer.cpp @@ -254,6 +254,8 @@ public: SkAutoTUnref gp( GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, this->color(), + this->usesLocalCoords(), + this->coverageIgnored(), this->viewMatrix(), SkMatrix::I(), this->coverage())); @@ -263,16 +265,6 @@ public: batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); // compute number of vertices @@ -518,6 +510,7 @@ private: bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; } const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; } bool isHairline() const { return fBatch.fIsHairline; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } struct BatchTracker { GrColor fColor; diff --git a/src/gpu/GrGeometryProcessor.h b/src/gpu/GrGeometryProcessor.h index eee286b20d..9c55359af5 100644 --- a/src/gpu/GrGeometryProcessor.h +++ b/src/gpu/GrGeometryProcessor.h @@ -26,6 +26,9 @@ public: bool willUseGeoShader() const { return fWillUseGeoShader; } + // TODO delete when paths are in batch + void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override {} + // TODO delete this when paths are in batch bool canMakeEqual(const GrBatchTracker& mine, const GrPrimitiveProcessor& that, @@ -43,35 +46,6 @@ public: } protected: - /* - * An optional simple helper function to determine by what means the GrGeometryProcessor should - * use to provide color. If we are given an override color(ie the given overridecolor is NOT - * GrColor_ILLEGAL) then we must always emit that color(currently overrides are only supported - * via uniform, but with deferred Geometry we could use attributes). Otherwise, if our color is - * ignored then we should not emit a color. Lastly, if we don't have vertex colors then we must - * emit a color via uniform - * TODO this function changes quite a bit with deferred geometry. There the GrGeometryProcessor - * can upload a new color via attribute if needed. - */ - static GrGPInput GetColorInputType(GrColor* color, GrColor primitiveColor, - const GrPipelineInfo& init, - bool hasVertexColor) { - if (init.fColorIgnored) { - *color = GrColor_ILLEGAL; - return kIgnored_GrGPInput; - } else if (GrColor_ILLEGAL != init.fOverrideColor) { - *color = init.fOverrideColor; - return kUniform_GrGPInput; - } - - *color = primitiveColor; - if (hasVertexColor) { - return kAttribute_GrGPInput; - } else { - return kUniform_GrGPInput; - } - } - /** * Subclasses call this from their constructor to register vertex attributes. Attributes * will be padded to the nearest 4 bytes for performance reasons. diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp index 0a7b3f89fc..69baebb228 100644 --- a/src/gpu/GrOvalRenderer.cpp +++ b/src/gpu/GrOvalRenderer.cpp @@ -71,14 +71,17 @@ inline bool circle_stays_circle(const SkMatrix& m) { class CircleEdgeEffect : public GrGeometryProcessor { public: - static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) { - return SkNEW_ARGS(CircleEdgeEffect, (color, stroke, localMatrix)); + static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(CircleEdgeEffect, (color, stroke, localMatrix, usesLocalCoords)); } const Attribute* inPosition() const { return fInPosition; } const Attribute* inCircleEdge() const { return fInCircleEdge; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } virtual ~CircleEdgeEffect() {} const char* name() const override { return "CircleEdge"; } @@ -94,7 +97,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const CircleEdgeEffect& ce = args.fGP.cast(); GrGLGPBuilder* pb = args.fPB; - const BatchTracker& local = args.fBT.cast(); GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); // emit attributes @@ -104,9 +106,10 @@ public: args.fPB->addVarying("CircleEdge", &v); vsBuilder->codeAppendf("%s = %s;", v.vsOut(), ce.inCircleEdge()->fName); - // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + // setup pass through color + if (!ce.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, ce.inPosition()->fName); @@ -131,22 +134,22 @@ public: const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const BatchTracker& local = bt.cast(); const CircleEdgeEffect& ce = gp.cast(); uint16_t key = ce.isStroked() ? 0x1 : 0x0; - key |= local.fUsesLocalCoords && ce.localMatrix().hasPerspective() ? 0x2 : 0x0; - b->add32(key << 16 | local.fInputColorType); + key |= ce.usesLocalCoords() && ce.localMatrix().hasPerspective() ? 0x2 : 0x0; + key |= ce.colorIgnored() ? 0x4 : 0x0; + b->add32(key); } virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { - const BatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const CircleEdgeEffect& ce = gp.cast(); + if (ce.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(ce.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = ce.color(); } } @@ -174,16 +177,11 @@ public: return SkNEW_ARGS(GLProcessor, (*this, bt)); } - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override { - BatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; - } - private: - CircleEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix) + CircleEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix, bool usesLocalCoords) : fColor(color) - , fLocalMatrix(localMatrix) { + , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInCircleEdge = &this->addVertexAttrib(Attribute("inCircleEdge", @@ -191,17 +189,12 @@ private: fStroke = stroke; } - struct BatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; - }; - GrColor fColor; SkMatrix fLocalMatrix; const Attribute* fInPosition; const Attribute* fInCircleEdge; bool fStroke; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -216,7 +209,8 @@ GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random, GrTexture* textures[]) { return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool(), - GrTest::TestMatrix(random)); + GrTest::TestMatrix(random), + random->nextBool()); } /////////////////////////////////////////////////////////////////////////////// @@ -231,8 +225,9 @@ GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random, class EllipseEdgeEffect : public GrGeometryProcessor { public: - static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) { - return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke, localMatrix)); + static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke, localMatrix, usesLocalCoords)); } virtual ~EllipseEdgeEffect() {} @@ -243,7 +238,9 @@ public: const Attribute* inEllipseOffset() const { return fInEllipseOffset; } const Attribute* inEllipseRadii() const { return fInEllipseRadii; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } inline bool isStroked() const { return fStroke; } @@ -256,7 +253,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const EllipseEdgeEffect& ee = args.fGP.cast(); GrGLGPBuilder* pb = args.fPB; - const BatchTracker& local = args.fBT.cast(); GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); // emit attributes @@ -272,9 +268,10 @@ public: vsBuilder->codeAppendf("%s = %s;", ellipseRadii.vsOut(), ee.inEllipseRadii()->fName); - // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + // setup pass through color + if (!ee.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, ee.inPosition()->fName); @@ -314,23 +311,22 @@ public: const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const BatchTracker& local = bt.cast(); const EllipseEdgeEffect& ee = gp.cast(); uint16_t key = ee.isStroked() ? 0x1 : 0x0; - key |= local.fUsesLocalCoords && ee.localMatrix().hasPerspective() ? 0x2 : 0x0; - b->add32(key << 16 | local.fInputColorType); + key |= ee.usesLocalCoords() && ee.localMatrix().hasPerspective() ? 0x2 : 0x0; + key |= ee.colorIgnored() ? 0x4 : 0x0; + b->add32(key); } virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { - - const BatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const EllipseEdgeEffect& ee = gp.cast(); + if (ee.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(ee.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = ee.color(); } } @@ -359,16 +355,12 @@ public: return SkNEW_ARGS(GLProcessor, (*this, bt)); } - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override { - BatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; - } - private: - EllipseEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix) + EllipseEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix, + bool usesLocalCoords) : fColor(color) - , fLocalMatrix(localMatrix) { + , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInEllipseOffset = &this->addVertexAttrib(Attribute("inEllipseOffset", @@ -378,18 +370,13 @@ private: fStroke = stroke; } - struct BatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; - }; - const Attribute* fInPosition; const Attribute* fInEllipseOffset; const Attribute* fInEllipseRadii; GrColor fColor; SkMatrix fLocalMatrix; bool fStroke; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -404,7 +391,8 @@ GrGeometryProcessor* EllipseEdgeEffect::TestCreate(SkRandom* random, GrTexture* textures[]) { return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool(), - GrTest::TestMatrix(random)); + GrTest::TestMatrix(random), + random->nextBool()); } /////////////////////////////////////////////////////////////////////////////// @@ -422,8 +410,9 @@ class DIEllipseEdgeEffect : public GrGeometryProcessor { public: enum Mode { kStroke = 0, kHairline, kFill }; - static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, Mode mode) { - return SkNEW_ARGS(DIEllipseEdgeEffect, (color, viewMatrix, mode)); + static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, Mode mode, + bool usesLocalCoords) { + return SkNEW_ARGS(DIEllipseEdgeEffect, (color, viewMatrix, mode, usesLocalCoords)); } virtual ~DIEllipseEdgeEffect() {} @@ -434,7 +423,9 @@ public: const Attribute* inEllipseOffsets0() const { return fInEllipseOffsets0; } const Attribute* inEllipseOffsets1() const { return fInEllipseOffsets1; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& viewMatrix() const { return fViewMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } inline Mode getMode() const { return fMode; } @@ -447,7 +438,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const DIEllipseEdgeEffect& ee = args.fGP.cast(); GrGLGPBuilder* pb = args.fPB; - const BatchTracker& local = args.fBT.cast(); GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); // emit attributes @@ -463,9 +453,10 @@ public: vsBuilder->codeAppendf("%s = %s;", offsets1.vsOut(), ee.inEllipseOffsets1()->fName); - // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + // setup pass through color + if (!ee.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, ee.inPosition()->fName, ee.viewMatrix()); @@ -519,11 +510,11 @@ public: const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const BatchTracker& local = bt.cast(); const DIEllipseEdgeEffect& ellipseEffect = gp.cast(); uint16_t key = ellipseEffect.getMode(); - key |= ComputePosKey(ellipseEffect.viewMatrix()) << 9; - b->add32(key << 16 | local.fInputColorType); + key |= ellipseEffect.colorIgnored() << 9; + key |= ComputePosKey(ellipseEffect.viewMatrix()) << 10; + b->add32(key); } virtual void setData(const GrGLProgramDataManager& pdman, @@ -532,12 +523,11 @@ public: const DIEllipseEdgeEffect& dee = gp.cast(); this->setUniformViewMatrix(pdman, dee.viewMatrix()); - const BatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (dee.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dee.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dee.color(); } } @@ -559,37 +549,28 @@ public: return SkNEW_ARGS(GLProcessor, (*this, bt)); } - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override { - BatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; - } - private: - DIEllipseEdgeEffect(GrColor color, const SkMatrix& viewMatrix, Mode mode) + DIEllipseEdgeEffect(GrColor color, const SkMatrix& viewMatrix, Mode mode, + bool usesLocalCoords) : fColor(color) - , fViewMatrix(viewMatrix) { + , fViewMatrix(viewMatrix) + , fUsesLocalCoords(usesLocalCoords) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInEllipseOffsets0 = &this->addVertexAttrib(Attribute("inEllipseOffsets0", - kVec2f_GrVertexAttribType)); + kVec2f_GrVertexAttribType)); fInEllipseOffsets1 = &this->addVertexAttrib(Attribute("inEllipseOffsets1", - kVec2f_GrVertexAttribType)); + kVec2f_GrVertexAttribType)); fMode = mode; } - struct BatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; - }; - const Attribute* fInPosition; const Attribute* fInEllipseOffsets0; const Attribute* fInEllipseOffsets1; GrColor fColor; SkMatrix fViewMatrix; Mode fMode; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -604,7 +585,8 @@ GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(SkRandom* random, GrTexture* textures[]) { return DIEllipseEdgeEffect::Create(GrRandomColor(random), GrTest::TestMatrix(random), - (Mode)(random->nextRangeU(0,2))); + (Mode)(random->nextRangeU(0,2)), + random->nextBool()); } /////////////////////////////////////////////////////////////////////////////// @@ -692,20 +674,11 @@ public: // Setup geometry processor SkAutoTUnref gp(CircleEdgeEffect::Create(this->color(), this->stroke(), - invert)); + invert, + this->usesLocalCoords())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(CircleVertex)); @@ -916,20 +889,11 @@ public: // Setup geometry processor SkAutoTUnref gp(EllipseEdgeEffect::Create(this->color(), this->stroke(), - invert)); + invert, + this->usesLocalCoords())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); QuadHelper helper; size_t vertexStride = gp->getVertexStride(); @@ -1184,20 +1148,11 @@ public: // Setup geometry processor SkAutoTUnref gp(DIEllipseEdgeEffect::Create(this->color(), this->viewMatrix(), - this->mode())); + this->mode(), + this->usesLocalCoords())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(DIEllipseVertex)); @@ -1549,20 +1504,11 @@ public: // Setup geometry processor SkAutoTUnref gp(CircleEdgeEffect::Create(this->color(), this->stroke(), - invert)); + invert, + this->usesLocalCoords())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(CircleVertex)); @@ -1731,20 +1677,11 @@ public: // Setup geometry processor SkAutoTUnref gp(EllipseEdgeEffect::Create(this->color(), this->stroke(), - invert)); + invert, + this->usesLocalCoords())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); size_t vertexStride = gp->getVertexStride(); SkASSERT(vertexStride == sizeof(EllipseVertex)); diff --git a/src/gpu/GrPathProcessor.cpp b/src/gpu/GrPathProcessor.cpp index 5c07a8b156..4660aa080f 100644 --- a/src/gpu/GrPathProcessor.cpp +++ b/src/gpu/GrPathProcessor.cpp @@ -57,12 +57,19 @@ bool GrPathProcessor::canMakeEqual(const GrBatchTracker& m, const PathBatchTracker& mine = m.cast(); const PathBatchTracker& theirs = t.cast(); - return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords, - that, theirs.fUsesLocalCoords) && - CanCombineOutput(mine.fInputColorType, mine.fColor, - theirs.fInputColorType, theirs.fColor) && - CanCombineOutput(mine.fInputCoverageType, 0xff, - theirs.fInputCoverageType, 0xff); + if (mine.fColor != theirs.fColor) { + return false; + } + + if (mine.fUsesLocalCoords != theirs.fUsesLocalCoords) { + return false; + } + + if (mine.fUsesLocalCoords && !this->localMatrix().cheapEqualTo(other.localMatrix())) { + return false; + } + + return true; } void GrPathProcessor::getGLProcessorKey(const GrBatchTracker& bt, diff --git a/src/gpu/GrPathProcessor.h b/src/gpu/GrPathProcessor.h index e34d0cefbe..7c1ab2b5df 100644 --- a/src/gpu/GrPathProcessor.h +++ b/src/gpu/GrPathProcessor.h @@ -57,38 +57,6 @@ public: private: GrPathProcessor(GrColor color, const SkMatrix& viewMatrix, const SkMatrix& localMatrix); - /* - * CanCombineOutput will return true if two draws are 'batchable' from a color perspective. - * TODO is this really necessary? - */ - static bool CanCombineOutput(GrGPInput left, GrColor lColor, GrGPInput right, GrColor rColor) { - if (left != right) { - return false; - } - - if (kUniform_GrGPInput == left && lColor != rColor) { - return false; - } - - return true; - } - - static bool CanCombineLocalMatrices(const GrPrimitiveProcessor& l, - bool leftUsesLocalCoords, - const GrPrimitiveProcessor& r, - bool rightUsesLocalCoords) { - if (leftUsesLocalCoords != rightUsesLocalCoords) { - return false; - } - - const GrPathProcessor& left = l.cast(); - const GrPathProcessor& right = r.cast(); - if (leftUsesLocalCoords && !left.localMatrix().cheapEqualTo(right.localMatrix())) { - return false; - } - return true; - } - bool hasExplicitLocalCoords() const override { return false; } GrColor fColor; diff --git a/src/gpu/GrRectBatch.cpp b/src/gpu/GrRectBatch.cpp index 100aafc4ca..bf085bdfdf 100644 --- a/src/gpu/GrRectBatch.cpp +++ b/src/gpu/GrRectBatch.cpp @@ -25,15 +25,19 @@ The vertex attrib order is always pos, color, [local coords]. */ static const GrGeometryProcessor* create_rect_gp(bool hasExplicitLocalCoords, - GrColor color, - const SkMatrix* localMatrix) { + const SkMatrix* localMatrix, + bool usesLocalCoords, + bool coverageIgnored) { + // TODO remove color when we have ignored color from the XP uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType | GrDefaultGeoProcFactory::kColor_GPType; flags |= hasExplicitLocalCoords ? GrDefaultGeoProcFactory::kLocalCoord_GPType : 0; if (localMatrix) { - return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), *localMatrix); + return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, + coverageIgnored, SkMatrix::I(), *localMatrix); } else { - return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), SkMatrix::I()); + return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, + coverageIgnored, SkMatrix::I(), SkMatrix::I()); } } @@ -98,21 +102,12 @@ public: } SkAutoTUnref gp(create_rect_gp(hasExplicitLocalCoords, - this->color(), - &invert)); + &invert, + this->usesLocalCoords(), + this->coverageIgnored())); batchTarget->initDraw(gp, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - int instanceCount = fGeoData.count(); size_t vertexStride = gp->getVertexStride(); SkASSERT(hasExplicitLocalCoords ? @@ -176,6 +171,7 @@ private: const SkMatrix& localMatrix() const { return fGeoData[0].fLocalMatrix; } bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; } bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } bool onCombineIfPossible(GrBatch* t) override { RectBatch* that = t->cast(); diff --git a/src/gpu/GrTessellatingPathRenderer.cpp b/src/gpu/GrTessellatingPathRenderer.cpp index 0fd8afd754..a41a88eed6 100644 --- a/src/gpu/GrTessellatingPathRenderer.cpp +++ b/src/gpu/GrTessellatingPathRenderer.cpp @@ -1412,9 +1412,10 @@ public: LOG("got %d pts, %d contours\n", maxPts, contourCnt); uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType; SkAutoTUnref gp( - GrDefaultGeoProcFactory::Create(flags, fColor, fViewMatrix, SkMatrix::I())); + GrDefaultGeoProcFactory::Create(flags, fColor, fPipelineInfo.fUsesLocalCoords, + fPipelineInfo.fCoverageIgnored, fViewMatrix, + SkMatrix::I())); batchTarget->initDraw(gp, pipeline); - gp->initBatchTracker(batchTarget->currentBatchTracker(), fPipelineInfo); SkAutoTDeleteArray contours(SkNEW_ARRAY(Vertex *, contourCnt)); diff --git a/src/gpu/GrTestBatch.h b/src/gpu/GrTestBatch.h index a165f4ab4e..aa0c63773e 100644 --- a/src/gpu/GrTestBatch.h +++ b/src/gpu/GrTestBatch.h @@ -50,16 +50,6 @@ public: void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override { batchTarget->initDraw(fGeometryProcessor, pipeline); - // TODO this is hacky, but the only way we have to initialize the GP is to use the - // GrPipelineInfo struct so we can generate the correct shader. Once we have GrBatch - // everywhere we can remove this nastiness - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = fBatch.fUsesLocalCoords; - fGeometryProcessor->initBatchTracker(batchTarget->currentBatchTracker(), init); - this->onGenerateGeometry(batchTarget, pipeline); } diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp index a09d6ce414..8d1b0dbd7a 100644 --- a/src/gpu/effects/GrBezierEffect.cpp +++ b/src/gpu/effects/GrBezierEffect.cpp @@ -12,13 +12,6 @@ #include "gl/GrGLGeometryProcessor.h" #include "gl/builders/GrGLProgramBuilder.h" -struct ConicBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - uint8_t fCoverageScale; - bool fUsesLocalCoords; -}; - class GrGLConicEffect : public GrGLGeometryProcessor { public: GrGLConicEffect(const GrGeometryProcessor&, @@ -37,16 +30,16 @@ public: const GrConicEffect& ce = primProc.cast(); this->setUniformViewMatrix(pdman, ce.viewMatrix()); - const ConicBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (ce.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(ce.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = ce.color(); } - if (0xff != local.fCoverageScale && fCoverageScale != local.fCoverageScale) { - pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale)); - fCoverageScale = local.fCoverageScale; + + if (ce.coverageScale() != 0xff && ce.coverageScale() != fCoverageScale) { + pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(ce.coverageScale())); + fCoverageScale = ce.coverageScale(); } } @@ -78,7 +71,6 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); const GrConicEffect& gp = args.fGP.cast(); - const ConicBatchTracker& local = args.fBT.cast(); // emit attributes vsBuilder->emitAttributes(gp); @@ -88,8 +80,9 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName); // Setup pass through color - this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + if (!gp.colorIgnored()) { + this->setupUniformColor(args.fPB, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix()); @@ -155,7 +148,8 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { SkFAIL("Shouldn't get here"); } - if (0xff != local.fCoverageScale) { + // TODO should we really be doing this? + if (gp.coverageScale() != 0xff) { const char* coverageScale; fCoverageScaleUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType, @@ -173,11 +167,10 @@ void GrGLConicEffect::GenKey(const GrGeometryProcessor& gp, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { const GrConicEffect& ce = gp.cast(); - const ConicBatchTracker& local = bt.cast(); uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; - key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; - key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; - key |= local.fUsesLocalCoords && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; + key |= GrColor_ILLEGAL != ce.color() ? 0x4 : 0x0; + key |= 0xff != ce.coverageScale() ? 0x8 : 0x0; + key |= ce.usesLocalCoords() && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; key |= ComputePosKey(ce.viewMatrix()) << 5; b->add32(key); } @@ -198,23 +191,18 @@ GrGLPrimitiveProcessor* GrConicEffect::createGLInstance(const GrBatchTracker& bt } GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage, - GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix) + GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix, + bool usesLocalCoords) : fColor(color) , fViewMatrix(viewMatrix) , fLocalMatrix(viewMatrix) + , fUsesLocalCoords(usesLocalCoords) , fCoverageScale(coverage) , fEdgeType(edgeType) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInConicCoeffs = &this->addVertexAttrib(Attribute("inConicCoeffs", - kVec4f_GrVertexAttribType)); -} - -void GrConicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - ConicBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fCoverageScale = fCoverageScale; - local->fUsesLocalCoords = init.fUsesLocalCoords; + kVec4f_GrVertexAttribType)); } ////////////////////////////////////////////////////////////////////////////// @@ -231,7 +219,7 @@ GrGeometryProcessor* GrConicEffect::TestCreate(SkRandom* random, random->nextULessThan(kGrProcessorEdgeTypeCnt)); gp = GrConicEffect::Create(GrRandomColor(random), GrTest::TestMatrix(random), edgeType, caps, - GrTest::TestMatrix(random)); + GrTest::TestMatrix(random), random->nextBool()); } while (NULL == gp); return gp; } @@ -240,13 +228,6 @@ GrGeometryProcessor* GrConicEffect::TestCreate(SkRandom* random, // Quad ////////////////////////////////////////////////////////////////////////////// -struct QuadBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - uint8_t fCoverageScale; - bool fUsesLocalCoords; -}; - class GrGLQuadEffect : public GrGLGeometryProcessor { public: GrGLQuadEffect(const GrGeometryProcessor&, @@ -265,16 +246,16 @@ public: const GrQuadEffect& qe = primProc.cast(); this->setUniformViewMatrix(pdman, qe.viewMatrix()); - const QuadBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (qe.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(qe.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = qe.color(); } - if (0xff != local.fCoverageScale && local.fCoverageScale != fCoverageScale) { - pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale)); - fCoverageScale = local.fCoverageScale; + + if (qe.coverageScale() != 0xff && qe.coverageScale() != fCoverageScale) { + pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(qe.coverageScale())); + fCoverageScale = qe.coverageScale(); } } @@ -306,7 +287,6 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); const GrQuadEffect& gp = args.fGP.cast(); - const QuadBatchTracker& local = args.fBT.cast(); // emit attributes vsBuilder->emitAttributes(gp); @@ -316,8 +296,9 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName); // Setup pass through color - this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + if (!gp.colorIgnored()) { + this->setupUniformColor(args.fPB, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix()); @@ -369,7 +350,7 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { SkFAIL("Shouldn't get here"); } - if (0xff != local.fCoverageScale) { + if (0xff != gp.coverageScale()) { const char* coverageScale; fCoverageScaleUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType, @@ -387,11 +368,10 @@ void GrGLQuadEffect::GenKey(const GrGeometryProcessor& gp, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { const GrQuadEffect& ce = gp.cast(); - const QuadBatchTracker& local = bt.cast(); uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; - key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; - key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; - key |= local.fUsesLocalCoords && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; + key |= ce.color() != GrColor_ILLEGAL ? 0x4 : 0x0; + key |= ce.coverageScale() != 0xff ? 0x8 : 0x0; + key |= ce.usesLocalCoords() && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; key |= ComputePosKey(ce.viewMatrix()) << 5; b->add32(key); } @@ -412,10 +392,12 @@ GrGLPrimitiveProcessor* GrQuadEffect::createGLInstance(const GrBatchTracker& bt, } GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage, - GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix) + GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix, + bool usesLocalCoords) : fColor(color) , fViewMatrix(viewMatrix) , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) , fCoverageScale(coverage) , fEdgeType(edgeType) { this->initClassID(); @@ -424,13 +406,6 @@ GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t co kVec4f_GrVertexAttribType)); } -void GrQuadEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - QuadBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fCoverageScale = fCoverageScale; - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - ////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect); @@ -446,7 +421,8 @@ GrGeometryProcessor* GrQuadEffect::TestCreate(SkRandom* random, gp = GrQuadEffect::Create(GrRandomColor(random), GrTest::TestMatrix(random), edgeType, caps, - GrTest::TestMatrix(random)); + GrTest::TestMatrix(random), + random->nextBool()); } while (NULL == gp); return gp; } @@ -455,12 +431,6 @@ GrGeometryProcessor* GrQuadEffect::TestCreate(SkRandom* random, // Cubic ////////////////////////////////////////////////////////////////////////////// -struct CubicBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - class GrGLCubicEffect : public GrGLGeometryProcessor { public: GrGLCubicEffect(const GrGeometryProcessor&, @@ -479,12 +449,11 @@ public: const GrCubicEffect& ce = primProc.cast(); this->setUniformViewMatrix(pdman, ce.viewMatrix()); - const CubicBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (ce.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(ce.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = ce.color(); } } @@ -506,7 +475,6 @@ GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor, void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); const GrCubicEffect& gp = args.fGP.cast(); - const CubicBatchTracker& local = args.fBT.cast(); // emit attributes vsBuilder->emitAttributes(gp); @@ -516,8 +484,9 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inCubicCoeffs()->fName); // Setup pass through color - this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + if (!gp.colorIgnored()) { + this->setupUniformColor(args.fPB, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(args.fPB, gpArgs, gp.inPosition()->fName, gp.viewMatrix()); @@ -618,9 +587,8 @@ void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { const GrCubicEffect& ce = gp.cast(); - const CubicBatchTracker& local = bt.cast(); uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; - key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x8; + key |= ce.color() != GrColor_ILLEGAL ? 0x4 : 0x8; key |= ComputePosKey(ce.viewMatrix()) << 5; b->add32(key); } @@ -651,12 +619,6 @@ GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix, kVec4f_GrVertexAttribType)); } -void GrCubicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - CubicBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - ////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect); diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h index f1b22fa8a4..7700c58fe6 100644 --- a/src/gpu/effects/GrBezierEffect.h +++ b/src/gpu/effects/GrBezierEffect.h @@ -63,6 +63,7 @@ public: const GrPrimitiveEdgeType edgeType, const GrDrawTargetCaps& caps, const SkMatrix& localMatrix, + bool usesLocalCoords, uint8_t coverage = 0xff) { switch (edgeType) { case kFillAA_GrProcessorEdgeType: @@ -71,18 +72,18 @@ public: } return SkNEW_ARGS(GrConicEffect, (color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); case kHairlineAA_GrProcessorEdgeType: if (!caps.shaderCaps()->shaderDerivativeSupport()) { return NULL; } return SkNEW_ARGS(GrConicEffect, (color, viewMatrix, coverage, kHairlineAA_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); case kFillBW_GrProcessorEdgeType: return SkNEW_ARGS(GrConicEffect, (color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); default: return NULL; } @@ -98,8 +99,11 @@ public: inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& viewMatrix() const { return fViewMatrix; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } + uint8_t coverageScale() const { return fCoverageScale; } virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, @@ -108,15 +112,14 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override; - private: GrConicEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType, - const SkMatrix& localMatrix); + const SkMatrix& localMatrix, bool usesLocalCoords); GrColor fColor; SkMatrix fViewMatrix; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; uint8_t fCoverageScale; GrPrimitiveEdgeType fEdgeType; const Attribute* fInPosition; @@ -145,6 +148,7 @@ public: const GrPrimitiveEdgeType edgeType, const GrDrawTargetCaps& caps, const SkMatrix& localMatrix, + bool usesLocalCoords, uint8_t coverage = 0xff) { switch (edgeType) { case kFillAA_GrProcessorEdgeType: @@ -153,18 +157,18 @@ public: } return SkNEW_ARGS(GrQuadEffect, (color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); case kHairlineAA_GrProcessorEdgeType: if (!caps.shaderCaps()->shaderDerivativeSupport()) { return NULL; } return SkNEW_ARGS(GrQuadEffect, (color, viewMatrix, coverage, kHairlineAA_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); case kFillBW_GrProcessorEdgeType: return SkNEW_ARGS(GrQuadEffect, (color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType, - localMatrix)); + localMatrix, usesLocalCoords)); default: return NULL; } @@ -180,8 +184,11 @@ public: inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& viewMatrix() const { return fViewMatrix; } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } + uint8_t coverageScale() const { return fCoverageScale; } virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, @@ -190,15 +197,14 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override; - private: GrQuadEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType, - const SkMatrix& localMatrix); + const SkMatrix& localMatrix, bool usesLocalCoords); GrColor fColor; SkMatrix fViewMatrix; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; uint8_t fCoverageScale; GrPrimitiveEdgeType fEdgeType; const Attribute* fInPosition; @@ -258,6 +264,7 @@ public: inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& viewMatrix() const { return fViewMatrix; } virtual void getGLProcessorKey(const GrBatchTracker& bt, @@ -267,8 +274,6 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override; - private: GrCubicEffect(GrColor, const SkMatrix& viewMatrix, GrPrimitiveEdgeType); diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp index a7261c0549..ad06792fb5 100644 --- a/src/gpu/effects/GrBitmapTextGeoProc.cpp +++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp @@ -15,12 +15,6 @@ #include "gl/GrGLGeometryProcessor.h" #include "gl/builders/GrGLProgramBuilder.h" -struct BitmapTextBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - class GrGLBitmapTextGeoProc : public GrGLGeometryProcessor { public: GrGLBitmapTextGeoProc(const GrGeometryProcessor&, const GrBatchTracker&) @@ -28,7 +22,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const GrBitmapTextGeoProc& cte = args.fGP.cast(); - const BitmapTextBatchTracker& local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder(); @@ -50,8 +43,13 @@ public: } // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, cte.inColor(), - &fColorUniform); + if (!cte.colorIgnored()) { + if (cte.hasVertexColor()) { + pb->addPassThroughAttribute(cte.inColor(), args.fOutputColor); + } else { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } + } // Setup position this->setupPosition(pb, gpArgs, cte.inPosition()->fName); @@ -79,12 +77,12 @@ public: virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { - const BitmapTextBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const GrBitmapTextGeoProc& btgp = gp.cast(); + if (btgp.color() != fColor && !btgp.hasVertexColor()) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(btgp.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = btgp.color(); } } @@ -99,16 +97,12 @@ public: const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const BitmapTextBatchTracker& local = bt.cast(); - // We have to put the optional vertex attribute as part of the key. See the comment - // on addVertexAttrib. - // TODO When we have deferred geometry we can fix this const GrBitmapTextGeoProc& gp = proc.cast(); uint32_t key = 0; - key |= SkToBool(gp.inColor()) ? 0x1 : 0x0; - key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x2 : 0x0; - key |= gp.maskFormat() == kARGB_GrMaskFormat ? 0x4 : 0x0; - b->add32(local.fInputColorType << 16 | key); + key |= gp.usesLocalCoords() && gp.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= gp.colorIgnored() ? 0x2 : 0x0; + key |= gp.maskFormat() << 3; + b->add32(key); } private: @@ -122,15 +116,18 @@ private: GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, GrTexture* texture, const GrTextureParams& params, GrMaskFormat format, - const SkMatrix& localMatrix) + const SkMatrix& localMatrix, bool usesLocalCoords) : fColor(color) , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) , fTextureAccess(texture, params) , fInColor(NULL) , fMaskFormat(format) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); + // TODO we could think about removing this attribute if color is ignored, but unfortunately + // we don't do text positioning in batch, so we can't quite do that yet. bool hasVertexColor = kA8_GrMaskFormat == fMaskFormat; if (hasVertexColor) { fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType)); @@ -152,13 +149,6 @@ GrBitmapTextGeoProc::createGLInstance(const GrBatchTracker& bt, return SkNEW_ARGS(GrGLBitmapTextGeoProc, (*this, bt)); } -void GrBitmapTextGeoProc::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - BitmapTextBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, - SkToBool(fInColor)); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrBitmapTextGeoProc); @@ -197,5 +187,5 @@ GrGeometryProcessor* GrBitmapTextGeoProc::TestCreate(SkRandom* random, } return GrBitmapTextGeoProc::Create(GrRandomColor(random), textures[texIdx], params, - format, GrTest::TestMatrix(random)); + format, GrTest::TestMatrix(random), random->nextBool()); } diff --git a/src/gpu/effects/GrBitmapTextGeoProc.h b/src/gpu/effects/GrBitmapTextGeoProc.h index 837dcb6fe5..2bd2726814 100644 --- a/src/gpu/effects/GrBitmapTextGeoProc.h +++ b/src/gpu/effects/GrBitmapTextGeoProc.h @@ -22,9 +22,10 @@ class GrInvariantOutput; class GrBitmapTextGeoProc : public GrGeometryProcessor { public: static GrGeometryProcessor* Create(GrColor color, GrTexture* tex, const GrTextureParams& p, - GrMaskFormat format, - const SkMatrix& localMatrix) { - return SkNEW_ARGS(GrBitmapTextGeoProc, (color, tex, p, format, localMatrix)); + GrMaskFormat format, const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(GrBitmapTextGeoProc, (color, tex, p, format, localMatrix, + usesLocalCoords)); } virtual ~GrBitmapTextGeoProc() {} @@ -36,7 +37,10 @@ public: const Attribute* inTextureCoords() const { return fInTextureCoords; } GrMaskFormat maskFormat() const { return fMaskFormat; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + bool hasVertexColor() const { return SkToBool(fInColor); } const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, @@ -45,14 +49,13 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps& caps) const override; - void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override; - private: GrBitmapTextGeoProc(GrColor, GrTexture* texture, const GrTextureParams& params, - GrMaskFormat format, const SkMatrix& localMatrix); + GrMaskFormat format, const SkMatrix& localMatrix, bool usesLocalCoords); GrColor fColor; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; GrTextureAccess fTextureAccess; const Attribute* fInPosition; const Attribute* fInColor; diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp index 1d873de749..8e942a1dfd 100644 --- a/src/gpu/effects/GrDashingEffect.cpp +++ b/src/gpu/effects/GrDashingEffect.cpp @@ -241,7 +241,8 @@ static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& m static GrGeometryProcessor* create_dash_gp(GrColor, DashAAMode aaMode, DashCap cap, - const SkMatrix& localMatrix); + const SkMatrix& localMatrix, + bool usesLocalCoords); class DashBatch : public GrBatch { public: @@ -315,25 +316,20 @@ public: bool isRoundCap = SkPaint::kRound_Cap == cap; DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap; if (this->fullDash()) { - gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, invert)); + gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, invert, + this->usesLocalCoords())); } else { // Set up the vertex data for the line and start/end dashes gp.reset(GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, this->color(), + this->usesLocalCoords(), + this->coverageIgnored(), SkMatrix::I(), invert)); } batchTarget->initDraw(gp, pipeline); - // TODO remove this when batch is everywhere - GrPipelineInfo init; - init.fColorIgnored = fBatch.fColorIgnored; - init.fOverrideColor = GrColor_ILLEGAL; - init.fCoverageIgnored = fBatch.fCoverageIgnored; - init.fUsesLocalCoords = this->usesLocalCoords(); - gp->initBatchTracker(batchTarget->currentBatchTracker(), init); - // useAA here means Edge AA or MSAA bool useAA = this->aaMode() != kBW_DashAAMode; bool fullDash = this->fullDash(); @@ -661,6 +657,7 @@ private: DashAAMode aaMode() const { return fBatch.fAAMode; } bool fullDash() const { return fBatch.fFullDash; } SkPaint::Cap cap() const { return fBatch.fCap; } + bool coverageIgnored() const { return fBatch.fCoverageIgnored; } struct BatchTracker { GrColor fColor; @@ -750,12 +747,6 @@ bool GrDashingEffect::DrawDashLine(GrDrawTarget* target, class GLDashingCircleEffect; -struct DashingCircleBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - /* * This effect will draw a dotted line (defined as a dashed lined with round caps and no on * interval). The radius of the dots is given by the strokeWidth and the spacing by the DashInfo. @@ -771,7 +762,8 @@ public: static GrGeometryProcessor* Create(GrColor, DashAAMode aaMode, - const SkMatrix& localMatrix); + const SkMatrix& localMatrix, + bool usesLocalCoords); const char* name() const override { return "DashingCircleEffect"; } @@ -785,8 +777,12 @@ public: GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } + virtual void getGLProcessorKey(const GrBatchTracker&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) const override; @@ -794,13 +790,13 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker&, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override; - private: - DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix); + DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix, + bool usesLocalCoords); GrColor fColor; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; DashAAMode fAAMode; const Attribute* fInPosition; const Attribute* fInDashParams; @@ -855,7 +851,6 @@ GLDashingCircleEffect::GLDashingCircleEffect(const GrGeometryProcessor&, void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { const DashingCircleEffect& dce = args.fGP.cast(); - const DashingCircleBatchTracker local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); @@ -873,7 +868,9 @@ void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { vsBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.inCircleParams()->fName); // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform); + if (!dce.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, dce.inPosition()->fName); @@ -904,12 +901,12 @@ void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& processor, const GrBatchTracker& bt) { - const DashingCircleBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const DashingCircleEffect& dce = processor.cast(); + if (dce.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dce.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dce.color(); } } @@ -917,20 +914,21 @@ void GLDashingCircleEffect::GenKey(const GrGeometryProcessor& gp, const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const DashingCircleBatchTracker& local = bt.cast(); const DashingCircleEffect& dce = gp.cast(); uint32_t key = 0; - key |= local.fUsesLocalCoords && dce.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= dce.usesLocalCoords() && dce.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= dce.colorIgnored() ? 0x2 : 0x0; key |= dce.aaMode() << 8; - b->add32(key << 16 | local.fInputColorType); + b->add32(key); } ////////////////////////////////////////////////////////////////////////////// GrGeometryProcessor* DashingCircleEffect::Create(GrColor color, DashAAMode aaMode, - const SkMatrix& localMatrix) { - return SkNEW_ARGS(DashingCircleEffect, (color, aaMode, localMatrix)); + const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(DashingCircleEffect, (color, aaMode, localMatrix, usesLocalCoords)); } void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt, @@ -946,9 +944,11 @@ GrGLPrimitiveProcessor* DashingCircleEffect::createGLInstance(const GrBatchTrack DashingCircleEffect::DashingCircleEffect(GrColor color, DashAAMode aaMode, - const SkMatrix& localMatrix) + const SkMatrix& localMatrix, + bool usesLocalCoords) : fColor(color) , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) , fAAMode(aaMode) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); @@ -957,12 +957,6 @@ DashingCircleEffect::DashingCircleEffect(GrColor color, kVec2f_GrVertexAttribType)); } -void DashingCircleEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - DashingCircleBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect); GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random, @@ -971,19 +965,14 @@ GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random, GrTexture*[]) { DashAAMode aaMode = static_cast(random->nextULessThan(kDashAAModeCount)); return DashingCircleEffect::Create(GrRandomColor(random), - aaMode, GrTest::TestMatrix(random)); + aaMode, GrTest::TestMatrix(random), + random->nextBool()); } ////////////////////////////////////////////////////////////////////////////// class GLDashingLineEffect; -struct DashingLineBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - /* * This effect will draw a dashed line. The width of the dash is given by the strokeWidth and the * length and spacing by the DashInfo. Both of the previous two parameters are in device space. @@ -999,7 +988,8 @@ public: static GrGeometryProcessor* Create(GrColor, DashAAMode aaMode, - const SkMatrix& localMatrix); + const SkMatrix& localMatrix, + bool usesLocalCoords); const char* name() const override { return "DashingEffect"; } @@ -1013,8 +1003,12 @@ public: GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + const SkMatrix& localMatrix() const { return fLocalMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } + virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override; @@ -1022,13 +1016,13 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override; - private: - DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix); + DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix, + bool usesLocalCoords); GrColor fColor; SkMatrix fLocalMatrix; + bool fUsesLocalCoords; DashAAMode fAAMode; const Attribute* fInPosition; const Attribute* fInDashParams; @@ -1076,7 +1070,6 @@ GLDashingLineEffect::GLDashingLineEffect(const GrGeometryProcessor&, void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { const DashingLineEffect& de = args.fGP.cast(); - const DashingLineBatchTracker& local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); @@ -1096,7 +1089,10 @@ void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { vsBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.inRectParams()->fName); // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform); + if (!de.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } + // Setup position this->setupPosition(pb, gpArgs, de.inPosition()->fName); @@ -1144,12 +1140,12 @@ void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& processor, const GrBatchTracker& bt) { - const DashingLineBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + const DashingLineEffect& de = processor.cast(); + if (de.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(de.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = de.color(); } } @@ -1157,20 +1153,21 @@ void GLDashingLineEffect::GenKey(const GrGeometryProcessor& gp, const GrBatchTracker& bt, const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - const DashingLineBatchTracker& local = bt.cast(); const DashingLineEffect& de = gp.cast(); uint32_t key = 0; - key |= local.fUsesLocalCoords && de.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= de.usesLocalCoords() && de.localMatrix().hasPerspective() ? 0x1 : 0x0; + key |= de.colorIgnored() ? 0x2 : 0x0; key |= de.aaMode() << 8; - b->add32(key << 16 | local.fInputColorType); + b->add32(key); } ////////////////////////////////////////////////////////////////////////////// GrGeometryProcessor* DashingLineEffect::Create(GrColor color, DashAAMode aaMode, - const SkMatrix& localMatrix) { - return SkNEW_ARGS(DashingLineEffect, (color, aaMode, localMatrix)); + const SkMatrix& localMatrix, + bool usesLocalCoords) { + return SkNEW_ARGS(DashingLineEffect, (color, aaMode, localMatrix, usesLocalCoords)); } void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt, @@ -1186,9 +1183,11 @@ GrGLPrimitiveProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker DashingLineEffect::DashingLineEffect(GrColor color, DashAAMode aaMode, - const SkMatrix& localMatrix) + const SkMatrix& localMatrix, + bool usesLocalCoords) : fColor(color) , fLocalMatrix(localMatrix) + , fUsesLocalCoords(usesLocalCoords) , fAAMode(aaMode) { this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); @@ -1196,12 +1195,6 @@ DashingLineEffect::DashingLineEffect(GrColor color, fInRectParams = &this->addVertexAttrib(Attribute("inRect", kVec4f_GrVertexAttribType)); } -void DashingLineEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { - DashingLineBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect); GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random, @@ -1210,7 +1203,7 @@ GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random, GrTexture*[]) { DashAAMode aaMode = static_cast(random->nextULessThan(kDashAAModeCount)); return DashingLineEffect::Create(GrRandomColor(random), - aaMode, GrTest::TestMatrix(random)); + aaMode, GrTest::TestMatrix(random), random->nextBool()); } ////////////////////////////////////////////////////////////////////////////// @@ -1218,12 +1211,13 @@ GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random, static GrGeometryProcessor* create_dash_gp(GrColor color, DashAAMode dashAAMode, DashCap cap, - const SkMatrix& localMatrix) { + const SkMatrix& localMatrix, + bool usesLocalCoords) { switch (cap) { case kRound_DashCap: - return DashingCircleEffect::Create(color, dashAAMode, localMatrix); + return DashingCircleEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords); case kNonRound_DashCap: - return DashingLineEffect::Create(color, dashAAMode, localMatrix); + return DashingLineEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords); default: SkFAIL("Unexpected dashed cap."); } diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp index ba42bb44f1..09228e505a 100755 --- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp +++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp @@ -21,12 +21,6 @@ // Assuming a radius of a little less than the diagonal of the fragment #define SK_DistanceFieldAAFactor "0.65" -struct DistanceFieldBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - class GrGLDistanceFieldA8TextGeoProc : public GrGLGeometryProcessor { public: GrGLDistanceFieldA8TextGeoProc(const GrGeometryProcessor&, @@ -40,7 +34,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const GrDistanceFieldA8TextGeoProc& dfTexEffect = args.fGP.cast(); - const DistanceFieldBatchTracker& local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); SkAssertResult(fsBuilder->enableFeature( @@ -61,8 +54,13 @@ public: #endif // Setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, - dfTexEffect.inColor(), &fColorUniform); + if (!dfTexEffect.colorIgnored()) { + if (dfTexEffect.hasVertexColor()) { + pb->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor); + } else { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } + } // Setup position this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEffect.viewMatrix()); @@ -154,12 +152,11 @@ public: const GrDistanceFieldA8TextGeoProc& dfa8gp = proc.cast(); this->setUniformViewMatrix(pdman, dfa8gp.viewMatrix()); - const DistanceFieldBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (dfa8gp.color() != fColor && !dfa8gp.hasVertexColor()) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dfa8gp.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dfa8gp.color(); } } @@ -168,9 +165,9 @@ public: const GrGLSLCaps&, GrProcessorKeyBuilder* b) { const GrDistanceFieldA8TextGeoProc& dfTexEffect = gp.cast(); - const DistanceFieldBatchTracker& local = bt.cast(); uint32_t key = dfTexEffect.getFlags(); - key |= local.fInputColorType << 16; + key |= dfTexEffect.hasVertexColor() << 16; + key |= dfTexEffect.colorIgnored() << 17; key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25; b->add32(key); } @@ -195,7 +192,8 @@ GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(GrColor color, #ifdef SK_GAMMA_APPLY_TO_A8 float distanceAdjust, #endif - uint32_t flags) + uint32_t flags, + bool usesLocalCoords) : fColor(color) , fViewMatrix(viewMatrix) , fTextureAccess(texture, params) @@ -203,7 +201,8 @@ GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(GrColor color, , fDistanceAdjust(distanceAdjust) #endif , fFlags(flags & kNonLCD_DistanceFieldEffectMask) - , fInColor(NULL) { + , fInColor(NULL) + , fUsesLocalCoords(usesLocalCoords) { SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); @@ -227,14 +226,6 @@ GrDistanceFieldA8TextGeoProc::createGLInstance(const GrBatchTracker& bt, return SkNEW_ARGS(GrGLDistanceFieldA8TextGeoProc, (*this, bt)); } -void GrDistanceFieldA8TextGeoProc::initBatchTracker(GrBatchTracker* bt, - const GrPipelineInfo& init) const { - DistanceFieldBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, - SkToBool(fInColor)); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldA8TextGeoProc); @@ -264,17 +255,12 @@ GrGeometryProcessor* GrDistanceFieldA8TextGeoProc::TestCreate(SkRandom* random, random->nextF(), #endif random->nextBool() ? - kSimilarity_DistanceFieldEffectFlag : 0); + kSimilarity_DistanceFieldEffectFlag : 0, + random->nextBool()); } /////////////////////////////////////////////////////////////////////////////// -struct DistanceFieldPathBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - class GrGLDistanceFieldPathGeoProc : public GrGLGeometryProcessor { public: GrGLDistanceFieldPathGeoProc(const GrGeometryProcessor&, @@ -284,7 +270,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const GrDistanceFieldPathGeoProc& dfTexEffect = args.fGP.cast(); - const DistanceFieldPathBatchTracker& local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); SkAssertResult(fsBuilder->enableFeature( @@ -299,9 +284,13 @@ public: args.fPB->addVarying("TextureCoords", &v, kHigh_GrSLPrecision); // setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, - dfTexEffect.inColor(), &fColorUniform); - + if (!dfTexEffect.colorIgnored()) { + if (dfTexEffect.hasVertexColor()) { + pb->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor); + } else { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } + } vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName); // Setup position @@ -384,12 +373,11 @@ public: const GrDistanceFieldPathGeoProc& dfpgp = proc.cast(); this->setUniformViewMatrix(pdman, dfpgp.viewMatrix()); - const DistanceFieldPathBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (dfpgp.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dfpgp.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dfpgp.color(); } } @@ -399,9 +387,9 @@ public: GrProcessorKeyBuilder* b) { const GrDistanceFieldPathGeoProc& dfTexEffect = gp.cast(); - const DistanceFieldPathBatchTracker& local = bt.cast(); uint32_t key = dfTexEffect.getFlags(); - key |= local.fInputColorType << 16; + key |= dfTexEffect.colorIgnored() << 16; + key |= dfTexEffect.hasVertexColor() << 17; key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25; b->add32(key); } @@ -422,12 +410,14 @@ GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc( const SkMatrix& viewMatrix, GrTexture* texture, const GrTextureParams& params, - uint32_t flags) + uint32_t flags, + bool usesLocalCoords) : fColor(color) , fViewMatrix(viewMatrix) , fTextureAccess(texture, params) , fFlags(flags & kNonLCD_DistanceFieldEffectMask) - , fInColor(NULL) { + , fInColor(NULL) + , fUsesLocalCoords(usesLocalCoords) { SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); @@ -435,7 +425,7 @@ GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc( fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType)); } fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", - kVec2f_GrVertexAttribType)); + kVec2f_GrVertexAttribType)); this->addTextureAccess(&fTextureAccess); } @@ -450,14 +440,6 @@ GrDistanceFieldPathGeoProc::createGLInstance(const GrBatchTracker& bt, const GrG return SkNEW_ARGS(GrGLDistanceFieldPathGeoProc, (*this, bt)); } -void GrDistanceFieldPathGeoProc::initBatchTracker(GrBatchTracker* bt, - const GrPipelineInfo& init) const { - DistanceFieldPathBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, - SkToBool(fInColor)); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldPathGeoProc); @@ -484,17 +466,13 @@ GrGeometryProcessor* GrDistanceFieldPathGeoProc::TestCreate(SkRandom* random, GrTest::TestMatrix(random), textures[texIdx], params, - random->nextBool() ? kSimilarity_DistanceFieldEffectFlag : 0); + random->nextBool() ? + kSimilarity_DistanceFieldEffectFlag : 0, + random->nextBool()); } /////////////////////////////////////////////////////////////////////////////// -struct DistanceFieldLCDBatchTracker { - GrGPInput fInputColorType; - GrColor fColor; - bool fUsesLocalCoords; -}; - class GrGLDistanceFieldLCDTextGeoProc : public GrGLGeometryProcessor { public: GrGLDistanceFieldLCDTextGeoProc(const GrGeometryProcessor&, const GrBatchTracker&) @@ -505,7 +483,6 @@ public: void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{ const GrDistanceFieldLCDTextGeoProc& dfTexEffect = args.fGP.cast(); - const DistanceFieldLCDBatchTracker& local = args.fBT.cast(); GrGLGPBuilder* pb = args.fPB; GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); @@ -514,8 +491,9 @@ public: vsBuilder->emitAttributes(dfTexEffect); // setup pass through color - this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, - &fColorUniform); + if (!dfTexEffect.colorIgnored()) { + this->setupUniformColor(pb, args.fOutputColor, &fColorUniform); + } // Setup position this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEffect.viewMatrix()); @@ -652,12 +630,11 @@ public: this->setUniformViewMatrix(pdman, dfTexEffect.viewMatrix()); - const DistanceFieldLCDBatchTracker& local = bt.cast(); - if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { + if (dfTexEffect.color() != fColor) { GrGLfloat c[4]; - GrColorToRGBAFloat(local.fColor, c); + GrColorToRGBAFloat(dfTexEffect.color(), c); pdman.set4fv(fColorUniform, 1, c); - fColor = local.fColor; + fColor = dfTexEffect.color(); } } @@ -667,9 +644,8 @@ public: GrProcessorKeyBuilder* b) { const GrDistanceFieldLCDTextGeoProc& dfTexEffect = gp.cast(); - const DistanceFieldLCDBatchTracker& local = bt.cast(); uint32_t key = dfTexEffect.getFlags(); - key |= local.fInputColorType << 16; + key |= dfTexEffect.colorIgnored() << 16; key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25; b->add32(key); } @@ -689,17 +665,18 @@ GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc( GrColor color, const SkMatrix& viewMatrix, GrTexture* texture, const GrTextureParams& params, DistanceAdjust distanceAdjust, - uint32_t flags) + uint32_t flags, bool usesLocalCoords) : fColor(color) , fViewMatrix(viewMatrix) , fTextureAccess(texture, params) , fDistanceAdjust(distanceAdjust) - , fFlags(flags & kLCD_DistanceFieldEffectMask){ + , fFlags(flags & kLCD_DistanceFieldEffectMask) + , fUsesLocalCoords(usesLocalCoords) { SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag)); this->initClassID(); fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", - kVec2s_GrVertexAttribType)); + kVec2s_GrVertexAttribType)); this->addTextureAccess(&fTextureAccess); } @@ -715,13 +692,6 @@ GrDistanceFieldLCDTextGeoProc::createGLInstance(const GrBatchTracker& bt, return SkNEW_ARGS(GrGLDistanceFieldLCDTextGeoProc, (*this, bt)); } -void GrDistanceFieldLCDTextGeoProc::initBatchTracker(GrBatchTracker* bt, - const GrPipelineInfo& init) const { - DistanceFieldLCDBatchTracker* local = bt->cast(); - local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); - local->fUsesLocalCoords = init.fUsesLocalCoords; -} - /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextGeoProc); @@ -751,5 +721,6 @@ GrGeometryProcessor* GrDistanceFieldLCDTextGeoProc::TestCreate(SkRandom* random, GrTest::TestMatrix(random), textures[texIdx], params, wa, - flags); + flags, + random->nextBool()); } diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.h b/src/gpu/effects/GrDistanceFieldGeoProc.h index ec661cedb8..42c397dd6c 100644 --- a/src/gpu/effects/GrDistanceFieldGeoProc.h +++ b/src/gpu/effects/GrDistanceFieldGeoProc.h @@ -49,15 +49,16 @@ public: #ifdef SK_GAMMA_APPLY_TO_A8 static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex, const GrTextureParams& params, - float lum, uint32_t flags) { + float lum, uint32_t flags, bool usesLocalCoords) { return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex, params, lum, - flags)); + flags, usesLocalCoords)); } #else static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex, const GrTextureParams& params, - uint32_t flags) { - return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex, params, flags)); + uint32_t flags, bool usesLocalCoords) { + return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex, params, flags, + usesLocalCoords)); } #endif @@ -69,7 +70,10 @@ public: const Attribute* inColor() const { return fInColor; } const Attribute* inTextureCoords() const { return fInTextureCoords; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + bool hasVertexColor() const { return SkToBool(fInColor); } const SkMatrix& viewMatrix() const { return fViewMatrix; } + bool usesLocalCoords() const { return fUsesLocalCoords; } #ifdef SK_GAMMA_APPLY_TO_A8 float getDistanceAdjust() const { return fDistanceAdjust; } #endif @@ -82,15 +86,13 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override; - private: GrDistanceFieldA8TextGeoProc(GrColor, const SkMatrix& viewMatrix, GrTexture* texture, const GrTextureParams& params, #ifdef SK_GAMMA_APPLY_TO_A8 float distanceAdjust, #endif - uint32_t flags); + uint32_t flags, bool usesLocalCoords); GrColor fColor; SkMatrix fViewMatrix; @@ -102,6 +104,7 @@ private: const Attribute* fInPosition; const Attribute* fInColor; const Attribute* fInTextureCoords; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -119,8 +122,9 @@ class GrDistanceFieldPathGeoProc : public GrGeometryProcessor { public: static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex, const GrTextureParams& params, - uint32_t flags) { - return SkNEW_ARGS(GrDistanceFieldPathGeoProc, (color, viewMatrix, tex, params, flags)); + uint32_t flags, bool usesLocalCoords) { + return SkNEW_ARGS(GrDistanceFieldPathGeoProc, (color, viewMatrix, tex, params, flags, + usesLocalCoords)); } virtual ~GrDistanceFieldPathGeoProc() {} @@ -131,8 +135,11 @@ public: const Attribute* inColor() const { return fInColor; } const Attribute* inTextureCoords() const { return fInTextureCoords; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } + bool hasVertexColor() const { return SkToBool(fInColor); } const SkMatrix& viewMatrix() const { return fViewMatrix; } uint32_t getFlags() const { return fFlags; } + bool usesLocalCoords() const { return fUsesLocalCoords; } virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, @@ -141,11 +148,10 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override; - private: GrDistanceFieldPathGeoProc(GrColor, const SkMatrix& viewMatrix, GrTexture* texture, - const GrTextureParams& params, uint32_t flags); + const GrTextureParams& params, uint32_t flags, + bool usesLocalCoords); GrColor fColor; SkMatrix fViewMatrix; @@ -154,6 +160,7 @@ private: const Attribute* fInPosition; const Attribute* fInColor; const Attribute* fInTextureCoords; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; @@ -185,9 +192,10 @@ public: static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex, const GrTextureParams& params, - DistanceAdjust distanceAdjust, uint32_t flags) { + DistanceAdjust distanceAdjust, uint32_t flags, + bool usesLocalCoords) { return SkNEW_ARGS(GrDistanceFieldLCDTextGeoProc, - (color, viewMatrix, tex, params, distanceAdjust, flags)); + (color, viewMatrix, tex, params, distanceAdjust, flags, usesLocalCoords)); } virtual ~GrDistanceFieldLCDTextGeoProc() {} @@ -198,8 +206,10 @@ public: const Attribute* inTextureCoords() const { return fInTextureCoords; } DistanceAdjust getDistanceAdjust() const { return fDistanceAdjust; } GrColor color() const { return fColor; } + bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } const SkMatrix& viewMatrix() const { return fViewMatrix; } uint32_t getFlags() const { return fFlags; } + bool usesLocalCoords() const { return fUsesLocalCoords; } virtual void getGLProcessorKey(const GrBatchTracker& bt, const GrGLSLCaps& caps, @@ -208,12 +218,11 @@ public: virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, const GrGLSLCaps&) const override; - void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override; - private: GrDistanceFieldLCDTextGeoProc(GrColor, const SkMatrix& viewMatrix, GrTexture* texture, const GrTextureParams& params, - DistanceAdjust wa, uint32_t flags); + DistanceAdjust wa, uint32_t flags, + bool usesLocalCoords); GrColor fColor; SkMatrix fViewMatrix; @@ -222,6 +231,7 @@ private: uint32_t fFlags; const Attribute* fInPosition; const Attribute* fInTextureCoords; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST; diff --git a/src/gpu/gl/GrGLPrimitiveProcessor.cpp b/src/gpu/gl/GrGLPrimitiveProcessor.cpp index 3213ffa8e2..d719774a66 100644 --- a/src/gpu/gl/GrGLPrimitiveProcessor.cpp +++ b/src/gpu/gl/GrGLPrimitiveProcessor.cpp @@ -31,28 +31,18 @@ SkMatrix GrGLPrimitiveProcessor::GetTransformMatrix(const SkMatrix& localMatrix, return combined; } -void -GrGLPrimitiveProcessor::setupColorPassThrough(GrGLGPBuilder* pb, - GrGPInput inputType, - const char* outputName, - const GrGeometryProcessor::Attribute* colorAttr, - UniformHandle* colorUniform) { +void GrGLPrimitiveProcessor::setupUniformColor(GrGLGPBuilder* pb, + const char* outputName, + UniformHandle* colorUniform) { GrGLFragmentBuilder* fs = pb->getFragmentShaderBuilder(); - if (kUniform_GrGPInput == inputType) { - SkASSERT(colorUniform); - const char* stagedLocalVarName; - *colorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, - kVec4f_GrSLType, - kDefault_GrSLPrecision, - "Color", - &stagedLocalVarName); - fs->codeAppendf("%s = %s;", outputName, stagedLocalVarName); - } else if (kAttribute_GrGPInput == inputType) { - SkASSERT(colorAttr); - pb->addPassThroughAttribute(colorAttr, outputName); - } else if (kAllOnes_GrGPInput == inputType) { - fs->codeAppendf("%s = vec4(1);", outputName); - } + SkASSERT(colorUniform); + const char* stagedLocalVarName; + *colorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility, + kVec4f_GrSLType, + kDefault_GrSLPrecision, + "Color", + &stagedLocalVarName); + fs->codeAppendf("%s = %s;", outputName, stagedLocalVarName); } void GrGLPrimitiveProcessor::addUniformViewMatrix(GrGLGPBuilder* pb) { diff --git a/src/gpu/gl/GrGLPrimitiveProcessor.h b/src/gpu/gl/GrGLPrimitiveProcessor.h index 30b1c178cd..90ee2038f8 100644 --- a/src/gpu/gl/GrGLPrimitiveProcessor.h +++ b/src/gpu/gl/GrGLPrimitiveProcessor.h @@ -74,16 +74,7 @@ public: static SkMatrix GetTransformMatrix(const SkMatrix& localMatrix, const GrCoordTransform&); protected: - /** a helper which can setup vertex, constant, or uniform color depending on inputType. - * This function will only do the minimum required to emit the correct shader code. If - * inputType == attribute, then colorAttr must not be NULL. Likewise, if inputType == Uniform - * then colorUniform must not be NULL. - */ - void setupColorPassThrough(GrGLGPBuilder* pb, - GrGPInput inputType, - const char* inputName, - const GrPrimitiveProcessor::Attribute* colorAttr, - UniformHandle* colorUniform); + void setupUniformColor(GrGLGPBuilder* pb, const char* outputName, UniformHandle* colorUniform); const char* uViewM() const { return fViewMatrixName; }