diff options
58 files changed, 855 insertions, 827 deletions
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp index b25ba7e723..b96952a1e0 100644 --- a/gm/beziereffects.cpp +++ b/gm/beziereffects.cpp @@ -150,7 +150,7 @@ protected: context->getTestTarget(&tt); SkASSERT(tt.target()); - GrDrawState ds; + GrPipelineBuilder pipelineBuilder; GrDrawTarget::AutoReleaseGeometry geo(tt.target(), 4, gp->getVertexStride(), 0); SkASSERT(gp->getVertexStride() == sizeof(Vertex)); @@ -165,10 +165,11 @@ protected: verts[v].fKLM[2] = eval_line(verts[v].fPosition, klmEqs + 6, 1.f); } - ds.setRenderTarget(rt); + pipelineBuilder.setRenderTarget(rt); tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer()); - tt.target()->drawIndexed(&ds, gp, kTriangleFan_GrPrimitiveType, 0, 0,4,6); + tt.target()->drawIndexed(&pipelineBuilder, gp, kTriangleFan_GrPrimitiveType, + 0, 0,4,6); } ++col; if (numCols == col) { @@ -306,7 +307,7 @@ protected: context->getTestTarget(&tt); SkASSERT(tt.target()); - GrDrawState ds; + GrPipelineBuilder pipelineBuilder; GrDrawTarget::AutoReleaseGeometry geo(tt.target(), 4, gp->getVertexStride(), 0); SkASSERT(gp->getVertexStride() == sizeof(Vertex)); @@ -321,10 +322,11 @@ protected: verts[v].fKLM[2] = eval_line(verts[v].fPosition, klmEqs + 6, 1.f); } - ds.setRenderTarget(rt); + pipelineBuilder.setRenderTarget(rt); tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer()); - tt.target()->drawIndexed(&ds, gp, kTriangleFan_GrPrimitiveType, 0, 0,4,6); + tt.target()->drawIndexed(&pipelineBuilder, gp, kTriangleFan_GrPrimitiveType, + 0, 0,4,6); } ++col; if (numCols == col) { @@ -493,7 +495,7 @@ protected: context->getTestTarget(&tt); SkASSERT(tt.target()); - GrDrawState ds; + GrPipelineBuilder pipelineBuilder; GrDrawTarget::AutoReleaseGeometry geo(tt.target(), 4, gp->getVertexStride(), 0); SkASSERT(gp->getVertexStride() == sizeof(Vertex)); @@ -506,10 +508,11 @@ protected: GrPathUtils::QuadUVMatrix DevToUV(pts); DevToUV.apply<4, sizeof(Vertex), sizeof(SkPoint)>(verts); - ds.setRenderTarget(rt); + pipelineBuilder.setRenderTarget(rt); tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer()); - tt.target()->drawIndexed(&ds, gp, kTriangles_GrPrimitiveType, 0, 0, 4, 6); + tt.target()->drawIndexed(&pipelineBuilder, gp, kTriangles_GrPrimitiveType, + 0, 0, 4, 6); } ++col; if (numCols == col) { diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp index 1ec7853dad..c92fd93390 100644 --- a/gm/convexpolyeffect.cpp +++ b/gm/convexpolyeffect.cpp @@ -132,12 +132,12 @@ protected: continue; } - GrDrawState ds; + GrPipelineBuilder pipelineBuilder; SkAutoTUnref<const GrGeometryProcessor> gp( GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, 0xff000000)); - ds.addCoverageProcessor(fp); - ds.setRenderTarget(rt); + pipelineBuilder.addCoverageProcessor(fp); + pipelineBuilder.setRenderTarget(rt); GrDrawTarget::AutoReleaseGeometry geo(tt.target(), 4, gp->getVertexStride(), 0); SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); @@ -150,7 +150,8 @@ protected: bounds.toQuad(verts); tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer()); - tt.target()->drawIndexed(&ds, gp, kTriangleFan_GrPrimitiveType, 0, 0, 4, 6); + tt.target()->drawIndexed(&pipelineBuilder, gp, kTriangleFan_GrPrimitiveType, + 0, 0, 4, 6); x += SkScalarCeilToScalar(path->getBounds().width() + 10.f); } @@ -189,12 +190,12 @@ protected: continue; } - GrDrawState ds; + GrPipelineBuilder pipelineBuilder; SkAutoTUnref<const GrGeometryProcessor> gp( GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, 0xff000000)); - ds.addCoverageProcessor(fp); - ds.setRenderTarget(rt); + pipelineBuilder.addCoverageProcessor(fp); + pipelineBuilder.setRenderTarget(rt); GrDrawTarget::AutoReleaseGeometry geo(tt.target(), 4, gp->getVertexStride(), 0); SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); @@ -205,7 +206,8 @@ protected: bounds.toQuad(verts); tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer()); - tt.target()->drawIndexed(&ds, gp, kTriangleFan_GrPrimitiveType, 0, 0, 4, 6); + tt.target()->drawIndexed(&pipelineBuilder, gp, kTriangleFan_GrPrimitiveType, + 0, 0, 4, 6); x += SkScalarCeilToScalar(rect.width() + 10.f); } diff --git a/gm/rrects.cpp b/gm/rrects.cpp index 6016891991..26d9194655 100644 --- a/gm/rrects.cpp +++ b/gm/rrects.cpp @@ -112,7 +112,7 @@ protected: SkDEBUGFAIL("Couldn't get Gr test target."); return; } - GrDrawState drawState; + GrPipelineBuilder pipelineBuilder; SkRRect rrect = fRRects[curRRect]; rrect.offset(SkIntToScalar(x), SkIntToScalar(y)); @@ -120,13 +120,13 @@ protected: SkAutoTUnref<GrFragmentProcessor> fp(GrRRectEffect::Create(edgeType, rrect)); if (fp) { - drawState.addCoverageProcessor(fp); - drawState.setRenderTarget(rt); + pipelineBuilder.addCoverageProcessor(fp); + pipelineBuilder.setRenderTarget(rt); SkRect bounds = rrect.getBounds(); bounds.outset(2.f, 2.f); - tt.target()->drawSimpleRect(&drawState, 0xff000000, SkMatrix::I(), + tt.target()->drawSimpleRect(&pipelineBuilder, 0xff000000, SkMatrix::I(), bounds); } else { drew = false; diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp index 9ea45e13f4..7b74cec7b5 100644 --- a/gm/texturedomaineffect.cpp +++ b/gm/texturedomaineffect.cpp @@ -130,11 +130,12 @@ protected: } SkMatrix viewMatrix; viewMatrix.setTranslate(x, y); - GrDrawState drawState; - drawState.setRenderTarget(rt); - drawState.addColorProcessor(fp); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(rt); + pipelineBuilder.addColorProcessor(fp); - tt.target()->drawSimpleRect(&drawState, GrColor_WHITE, viewMatrix, renderRect); + tt.target()->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, viewMatrix, + renderRect); x += renderRect.width() + kTestPad; } y += renderRect.height() + kTestPad; diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp index 3be01cc2c3..21d42cbd14 100644 --- a/gm/yuvtorgbeffect.cpp +++ b/gm/yuvtorgbeffect.cpp @@ -115,10 +115,11 @@ protected: if (fp) { SkMatrix viewMatrix; viewMatrix.setTranslate(x, y); - GrDrawState drawState; - drawState.setRenderTarget(rt); - drawState.addColorProcessor(fp); - tt.target()->drawSimpleRect(&drawState, GrColor_WHITE, viewMatrix, renderRect); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(rt); + pipelineBuilder.addColorProcessor(fp); + tt.target()->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, viewMatrix, + renderRect); } x += renderRect.width() + kTestPad; } diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi index b46780da69..77b29ff57e 100644 --- a/gyp/gpu.gypi +++ b/gyp/gpu.gypi @@ -76,8 +76,6 @@ '<(skia_src_path)/gpu/GrDefaultPathRenderer.h', '<(skia_src_path)/gpu/GrDistanceFieldTextContext.h', '<(skia_src_path)/gpu/GrDistanceFieldTextContext.cpp', - '<(skia_src_path)/gpu/GrDrawState.cpp', - '<(skia_src_path)/gpu/GrDrawState.h', '<(skia_src_path)/gpu/GrDrawTarget.cpp', '<(skia_src_path)/gpu/GrDrawTarget.h', '<(skia_src_path)/gpu/GrDrawTargetCaps.h', @@ -106,8 +104,6 @@ '<(skia_src_path)/gpu/GrMemoryPool.cpp', '<(skia_src_path)/gpu/GrMemoryPool.h', '<(skia_src_path)/gpu/GrMurmur3HashKey.h', - '<(skia_src_path)/gpu/GrOptDrawState.cpp', - '<(skia_src_path)/gpu/GrOptDrawState.h', '<(skia_src_path)/gpu/GrOrderedSet.h', '<(skia_src_path)/gpu/GrOvalRenderer.cpp', '<(skia_src_path)/gpu/GrOvalRenderer.h', @@ -125,6 +121,10 @@ '<(skia_src_path)/gpu/GrPathUtils.h', '<(skia_src_path)/gpu/GrPendingProgramElement.h', '<(skia_src_path)/gpu/GrPendingFragmentStage.h', + '<(skia_src_path)/gpu/GrPipeline.cpp', + '<(skia_src_path)/gpu/GrPipeline.h', + '<(skia_src_path)/gpu/GrPipelineBuilder.cpp', + '<(skia_src_path)/gpu/GrPipelineBuilder.h', '<(skia_src_path)/gpu/GrProgramDesc.h', '<(skia_src_path)/gpu/GrProgramElement.cpp', '<(skia_src_path)/gpu/GrProcessor.cpp', diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h index 23711b98ca..70d34c5c97 100644 --- a/include/gpu/GrContext.h +++ b/include/gpu/GrContext.h @@ -19,7 +19,6 @@ #include "SkTypes.h" class GrAARectRenderer; -class GrDrawState; class GrDrawTarget; class GrFontCache; class GrFragmentProcessor; @@ -32,6 +31,7 @@ class GrLayerCache; class GrOvalRenderer; class GrPath; class GrPathRenderer; +class GrPipelineBuilder; class GrResourceEntry; class GrResourceCache2; class GrTestTarget; @@ -773,7 +773,7 @@ public: GrPathRenderer* getPathRenderer( const GrDrawTarget* target, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -861,10 +861,10 @@ private: class AutoCheckFlush; // Sets the paint and returns the target to draw into. This function is overloaded to either // take a GrDrawState, GrPaint, and AutoCheckFlush, or JUST an AutoCheckFlush - GrDrawTarget* prepareToDraw(GrDrawState* ds, const GrPaint* paint, const AutoCheckFlush*); + GrDrawTarget* prepareToDraw(GrPipelineBuilder*, const GrPaint* paint, const AutoCheckFlush*); void internalDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, const SkMatrix& viewMatrix, GrColor, bool useAA, diff --git a/include/gpu/GrPathRendererChain.h b/include/gpu/GrPathRendererChain.h index 07d64949b2..9c4b976c9c 100644 --- a/include/gpu/GrPathRendererChain.h +++ b/include/gpu/GrPathRendererChain.h @@ -12,9 +12,9 @@ #include "SkTArray.h" class GrContext; -class GrDrawState; class GrDrawTarget; class GrPathRenderer; +class GrPipelineBuilder; class SkMatrix; class SkPath; class SkStrokeRec; @@ -58,7 +58,7 @@ public: whether the path can be rendered with arbitrary stencil rules or not. See comments on StencilSupport in GrPathRenderer.h. */ GrPathRenderer* getPathRenderer(const GrDrawTarget* target, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& rec, diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp index 27cc8aa3be..031dac3c48 100644 --- a/src/gpu/GrAAConvexPathRenderer.cpp +++ b/src/gpu/GrAAConvexPathRenderer.cpp @@ -9,12 +9,12 @@ #include "GrAAConvexPathRenderer.h" #include "GrContext.h" -#include "GrDrawState.h" #include "GrDrawTargetCaps.h" #include "GrGeometryProcessor.h" #include "GrInvariantOutput.h" -#include "GrProcessor.h" #include "GrPathUtils.h" +#include "GrProcessor.h" +#include "GrPipelineBuilder.h" #include "SkGeometry.h" #include "SkString.h" #include "SkStrokeRec.h" @@ -694,7 +694,7 @@ GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random, /////////////////////////////////////////////////////////////////////////////// bool GrAAConvexPathRenderer::canDrawPath(const GrDrawTarget* target, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -704,7 +704,7 @@ bool GrAAConvexPathRenderer::canDrawPath(const GrDrawTarget* target, } bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& vm, const SkPath& origPath, @@ -782,7 +782,7 @@ bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target, int vOffset = 0; for (int i = 0; i < draws.count(); ++i) { const Draw& draw = draws[i]; - target->drawIndexed(drawState, + target->drawIndexed(pipelineBuilder, quadProcessor, kTriangles_GrPrimitiveType, vOffset, // start vertex diff --git a/src/gpu/GrAAConvexPathRenderer.h b/src/gpu/GrAAConvexPathRenderer.h index b07781f2f3..bb2d3f0a1e 100644 --- a/src/gpu/GrAAConvexPathRenderer.h +++ b/src/gpu/GrAAConvexPathRenderer.h @@ -16,7 +16,7 @@ public: GrAAConvexPathRenderer(); virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -24,7 +24,7 @@ public: protected: virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, diff --git a/src/gpu/GrAADistanceFieldPathRenderer.cpp b/src/gpu/GrAADistanceFieldPathRenderer.cpp index 99093faed7..b11769c7c7 100755 --- a/src/gpu/GrAADistanceFieldPathRenderer.cpp +++ b/src/gpu/GrAADistanceFieldPathRenderer.cpp @@ -10,7 +10,7 @@ #include "GrAtlas.h" #include "GrContext.h" -#include "GrDrawState.h" +#include "GrPipelineBuilder.h" #include "GrSurfacePriv.h" #include "GrSWMaskHelper.h" #include "GrTexturePriv.h" @@ -66,7 +66,7 @@ GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() { //////////////////////////////////////////////////////////////////////////////// bool GrAADistanceFieldPathRenderer::canDrawPath(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -95,7 +95,7 @@ bool GrAADistanceFieldPathRenderer::canDrawPath(const GrDrawTarget* target, GrPathRenderer::StencilSupport GrAADistanceFieldPathRenderer::onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const { return GrPathRenderer::kNoSupport_StencilSupport; @@ -104,7 +104,7 @@ GrAADistanceFieldPathRenderer::onGetStencilSupport(const GrDrawTarget*, //////////////////////////////////////////////////////////////////////////////// bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -144,7 +144,7 @@ bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target, } // use signed distance field to render - return this->internalDrawPath(target, drawState, color, viewMatrix, path, pathData); + return this->internalDrawPath(target, pipelineBuilder, color, viewMatrix, path, pathData); } // padding around path bounds to allow for antialiased pixels @@ -306,13 +306,13 @@ bool GrAADistanceFieldPathRenderer::freeUnusedPlot() { } bool GrAADistanceFieldPathRenderer::internalDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, const PathData* pathData) { GrTexture* texture = fAtlas->getTexture(); - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); SkASSERT(pathData->fPlot); GrDrawTarget::DrawToken drawToken = target->getCurrentDrawToken(); @@ -374,7 +374,7 @@ bool GrAADistanceFieldPathRenderer::internalDrawPath(GrDrawTarget* target, viewMatrix.mapRect(&r); target->setIndexSourceToBuffer(fContext->getQuadIndexBuffer()); - target->drawIndexedInstances(drawState, fCachedGeometryProcessor.get(), + target->drawIndexedInstances(pipelineBuilder, fCachedGeometryProcessor.get(), kTriangles_GrPrimitiveType, 1, 4, 6, &r); target->resetVertexSource(); diff --git a/src/gpu/GrAADistanceFieldPathRenderer.h b/src/gpu/GrAADistanceFieldPathRenderer.h index b17b3050c2..994c1ebfb8 100755 --- a/src/gpu/GrAADistanceFieldPathRenderer.h +++ b/src/gpu/GrAADistanceFieldPathRenderer.h @@ -25,7 +25,7 @@ public: virtual ~GrAADistanceFieldPathRenderer(); virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -33,12 +33,12 @@ public: protected: virtual StencilSupport onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const SK_OVERRIDE; virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -81,7 +81,7 @@ private: SkTDynamicHash<PathData, PathData::Key> fPathCache; PathDataList fPathList; - bool internalDrawPath(GrDrawTarget*, GrDrawState*, GrColor, const SkMatrix& viewMatrix, + bool internalDrawPath(GrDrawTarget*, GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath& path, const PathData* pathData); PathData* addPathToAtlas(const SkPath& path, const SkStrokeRec& stroke, bool antiAlias, uint32_t dimension, SkScalar scale); diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp index eea6463702..ce24cf8c26 100644 --- a/src/gpu/GrAAHairLinePathRenderer.cpp +++ b/src/gpu/GrAAHairLinePathRenderer.cpp @@ -9,11 +9,11 @@ #include "GrContext.h" #include "GrDefaultGeoProcFactory.h" -#include "GrDrawState.h" #include "GrDrawTargetCaps.h" #include "GrGpu.h" #include "GrIndexBuffer.h" #include "GrPathUtils.h" +#include "GrPipelineBuilder.h" #include "GrProcessor.h" #include "SkGeometry.h" #include "SkStroke.h" @@ -643,7 +643,7 @@ void add_line(const SkPoint p[2], /////////////////////////////////////////////////////////////////////////////// bool GrAAHairLinePathRenderer::createLineGeom(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, uint8_t coverage, size_t vertexStride, @@ -683,7 +683,7 @@ bool GrAAHairLinePathRenderer::createLineGeom(GrDrawTarget* target, } bool GrAAHairLinePathRenderer::createBezierGeom(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, GrDrawTarget::AutoReleaseGeometry* arg, SkRect* devBounds, @@ -743,7 +743,7 @@ bool GrAAHairLinePathRenderer::createBezierGeom(GrDrawTarget* target, } bool GrAAHairLinePathRenderer::canDrawPath(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -801,7 +801,7 @@ bool check_bounds(const SkMatrix& viewMatrix, const SkRect& devBounds, void* ver } bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -814,7 +814,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, } SkIRect devClipBounds; - target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds); + target->getClip()->getConservativeBounds(pipelineBuilder->getRenderTarget(), &devClipBounds); int lineCnt; int quadCnt; @@ -845,7 +845,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, GrDrawTarget::AutoReleaseGeometry arg; SkRect devBounds; - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); uint32_t gpFlags = GrDefaultGeoProcFactory::kPosition_GPType | GrDefaultGeoProcFactory::kCoverage_GPType; SkAutoTUnref<const GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Create(gpFlags, @@ -856,7 +856,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, newCoverage)); if (!this->createLineGeom(target, - drawState, + pipelineBuilder, viewMatrix, newCoverage, gp->getVertexStride(), @@ -879,7 +879,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, int lines = 0; while (lines < lineCnt) { int n = SkTMin(lineCnt - lines, kLineSegsNumInIdxBuffer); - target->drawIndexed(drawState, + target->drawIndexed(pipelineBuilder, gp, kTriangles_GrPrimitiveType, kLineSegNumVertices*lines, // startV @@ -898,7 +898,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, SkRect devBounds; if (!this->createBezierGeom(target, - drawState, + pipelineBuilder, viewMatrix, &arg, &devBounds, @@ -930,13 +930,13 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, invert, newCoverage)); SkASSERT(hairQuadProcessor); - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); target->setIndexSourceToBuffer(fQuadsIndexBuffer); int quads = 0; while (quads < quadCnt) { int n = SkTMin(quadCnt - quads, kQuadsNumInIdxBuffer); - target->drawIndexed(drawState, + target->drawIndexed(pipelineBuilder, hairQuadProcessor, kTriangles_GrPrimitiveType, kQuadNumVertices*quads, // startV @@ -953,13 +953,13 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target, GrConicEffect::Create(color, vm, kHairlineAA_GrProcessorEdgeType, *target->caps(), invert, newCoverage)); SkASSERT(hairConicProcessor); - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); target->setIndexSourceToBuffer(fQuadsIndexBuffer); int conics = 0; while (conics < conicCnt) { int n = SkTMin(conicCnt - conics, kQuadsNumInIdxBuffer); - target->drawIndexed(drawState, + target->drawIndexed(pipelineBuilder, hairConicProcessor, kTriangles_GrPrimitiveType, kQuadNumVertices*(quadCnt + conics), // startV diff --git a/src/gpu/GrAAHairLinePathRenderer.h b/src/gpu/GrAAHairLinePathRenderer.h index 8bc3e3e804..91c00d78c3 100644 --- a/src/gpu/GrAAHairLinePathRenderer.h +++ b/src/gpu/GrAAHairLinePathRenderer.h @@ -18,7 +18,7 @@ public: static GrPathRenderer* Create(GrContext* context); virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -30,7 +30,7 @@ public: protected: virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -43,7 +43,7 @@ private: const GrIndexBuffer* fQuadsIndexBuffer); bool createLineGeom(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, const SkMatrix& viewMatrix, uint8_t coverage, size_t vertexStride, @@ -54,7 +54,7 @@ private: int lineCnt); bool createBezierGeom(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, const SkMatrix& viewMatrix, GrDrawTarget::AutoReleaseGeometry* arg, SkRect* devBounds, diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp index 444bb519ac..0ffdd4d9f9 100644 --- a/src/gpu/GrAARectRenderer.cpp +++ b/src/gpu/GrAARectRenderer.cpp @@ -25,13 +25,13 @@ enum CoverageAttribType { }; } -static const GrGeometryProcessor* create_rect_gp(const GrDrawState& drawState, +static const GrGeometryProcessor* create_rect_gp(const GrPipelineBuilder& pipelineBuilder, GrColor color, CoverageAttribType* type, const SkMatrix& localMatrix) { uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType; const GrGeometryProcessor* gp; - if (drawState.canTweakAlphaForCoverage()) { + if (pipelineBuilder.canTweakAlphaForCoverage()) { gp = GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), localMatrix); SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)); *type = kUseColor_CoverageAttribType; @@ -179,12 +179,12 @@ GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(bool miterStroke) { } void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect& devRect) { - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); SkMatrix localMatrix; if (!viewMatrix.invert(&localMatrix)) { @@ -193,7 +193,7 @@ void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, } CoverageAttribType type; - SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type, + SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*pipelineBuilder, color, &type, localMatrix)); size_t vertexStride = gp->getVertexStride(); @@ -306,7 +306,7 @@ void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, } target->setIndexSourceToBuffer(indexBuffer); - target->drawIndexedInstances(drawState, + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, @@ -316,7 +316,7 @@ void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, } void GrAARectRenderer::strokeAARect(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, @@ -364,7 +364,7 @@ void GrAARectRenderer::strokeAARect(GrDrawTarget* target, } if (spare <= 0 && miterStroke) { - this->fillAARect(target, drawState, color, viewMatrix, devOutside, + this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside); return; } @@ -382,19 +382,19 @@ void GrAARectRenderer::strokeAARect(GrDrawTarget* target, devOutsideAssist.outset(0, ry); } - this->geometryStrokeAARect(target, drawState, color, viewMatrix, devOutside, devOutsideAssist, + this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutsideAssist, devInside, miterStroke); } void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect& devOutside, const SkRect& devOutsideAssist, const SkRect& devInside, bool miterStroke) { - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); SkMatrix localMatrix; if (!viewMatrix.invert(&localMatrix)) { @@ -403,7 +403,7 @@ void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, } CoverageAttribType type; - SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type, + SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*pipelineBuilder, color, &type, localMatrix)); int innerVertexNum = 4; @@ -517,7 +517,7 @@ void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, } target->setIndexSourceToBuffer(indexBuffer); - target->drawIndexedInstances(drawState, + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, @@ -527,7 +527,7 @@ void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, } void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect rects[2]) { @@ -540,11 +540,11 @@ void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target, viewMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2); if (devInside.isEmpty()) { - this->fillAARect(target, drawState, color, viewMatrix, devOutside, + this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside); return; } - this->geometryStrokeAARect(target, drawState, color, viewMatrix, devOutside, devOutsideAssist, - devInside, true); + this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside, + devOutsideAssist, devInside, true); } diff --git a/src/gpu/GrAARectRenderer.h b/src/gpu/GrAARectRenderer.h index d6d07dde12..5a96f2cbca 100644 --- a/src/gpu/GrAARectRenderer.h +++ b/src/gpu/GrAARectRenderer.h @@ -15,7 +15,7 @@ #include "SkStrokeRec.h" class GrGpu; -class GrDrawState; +class GrPipelineBuilder; class GrDrawTarget; class GrIndexBuffer; @@ -43,16 +43,16 @@ public: // between them by passing in stroke (==NULL means fill). void fillAARect(GrDrawTarget* target, - GrDrawState* ds, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect& devRect) { - this->geometryFillAARect(target, ds, color, viewMatrix, rect, devRect); + this->geometryFillAARect(target, pipelineBuilder, color, viewMatrix, rect, devRect); } void strokeAARect(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkRect& rect, @@ -61,7 +61,7 @@ public: // First rect is outer; second rect is inner void fillAANestedRects(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkRect rects[2]); @@ -70,14 +70,14 @@ private: GrIndexBuffer* aaStrokeRectIndexBuffer(bool miterStroke); void geometryFillAARect(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect& devRect); void geometryStrokeAARect(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkRect& devOutside, diff --git a/src/gpu/GrBitmapTextContext.cpp b/src/gpu/GrBitmapTextContext.cpp index 2df3a710d2..f39e7a1bb0 100755 --- a/src/gpu/GrBitmapTextContext.cpp +++ b/src/gpu/GrBitmapTextContext.cpp @@ -529,8 +529,8 @@ void GrBitmapTextContext::flush() { } if (fCurrVertex > 0) { - GrDrawState drawState; - drawState.setFromPaint(fPaint, fContext->getRenderTarget()); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setFromPaint(fPaint, fContext->getRenderTarget()); // setup our sampler state for our text texture/atlas SkASSERT(SkIsAlign4(fCurrVertex)); @@ -550,7 +550,8 @@ void GrBitmapTextContext::flush() { // TODO: move supportsRGBCoverage check to setupCoverageEffect and only add LCD // processor if the xp can support it. For now we will simply assume that if // fUseLCDText is true, then we have a known color output. - if (!drawState.getXPFactory()->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) { + const GrXPFactory* xpFactory = pipelineBuilder.getXPFactory(); + if (!xpFactory->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) { SkDebugf("LCD Text will not draw correctly.\n"); } break; @@ -574,7 +575,7 @@ void GrBitmapTextContext::flush() { params)); fEffectTextureUniqueID = textureUniqueID; } - drawState.addColorProcessor(fCachedTextureProcessor.get()); + pipelineBuilder.addColorProcessor(fCachedTextureProcessor.get()); } else { uint32_t textureUniqueID = fCurrTexture->getUniqueID(); if (textureUniqueID != fEffectTextureUniqueID || @@ -594,7 +595,7 @@ void GrBitmapTextContext::flush() { int nGlyphs = fCurrVertex / kVerticesPerGlyph; fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer()); - fDrawTarget->drawIndexedInstances(&drawState, + fDrawTarget->drawIndexedInstances(&pipelineBuilder, fCachedGeometryProcessor.get(), kTriangles_GrPrimitiveType, nGlyphs, diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp index c2dc4fb223..6bfdba6cce 100644 --- a/src/gpu/GrClipMaskManager.cpp +++ b/src/gpu/GrClipMaskManager.cpp @@ -31,9 +31,9 @@ namespace { // set up the draw state to enable the aa clipping mask. Besides setting up the // stage matrix this also alters the vertex layout void setup_drawstate_aaclip(const SkIRect &devBound, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrTexture* result) { - SkASSERT(drawState); + SkASSERT(pipelineBuilder); SkMatrix mat; // We use device coords to compute the texture coordinates. We set our matrix to be a @@ -44,7 +44,7 @@ void setup_drawstate_aaclip(const SkIRect &devBound, SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height()); // This could be a long-lived effect that is cached with the alpha-mask. - drawState->addCoverageProcessor( + pipelineBuilder->addCoverageProcessor( GrTextureDomainEffect::Create(result, mat, GrTextureDomain::MakeTexelDomain(result, domainTexels), @@ -55,7 +55,7 @@ void setup_drawstate_aaclip(const SkIRect &devBound, bool path_needs_SW_renderer(GrContext* context, const GrDrawTarget* gpu, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& origPath, const SkStrokeRec& stroke, @@ -70,7 +70,8 @@ bool path_needs_SW_renderer(GrContext* context, GrPathRendererChain::kColorAntiAlias_DrawType : GrPathRendererChain::kColor_DrawType; - return NULL == context->getPathRenderer(gpu, drawState, viewMatrix, *path, stroke, false, type); + return NULL == context->getPathRenderer(gpu, pipelineBuilder, viewMatrix, *path, stroke, + false, type); } } @@ -79,7 +80,7 @@ bool path_needs_SW_renderer(GrContext* context, * will be used on any element. If so, it returns true to indicate that the * entire clip should be rendered in SW and then uploaded en masse to the gpu. */ -bool GrClipMaskManager::useSWOnlyPath(const GrDrawState* drawState, +bool GrClipMaskManager::useSWOnlyPath(const GrPipelineBuilder* pipelineBuilder, const SkVector& clipToMaskOffset, const GrReducedClip::ElementList& elements) { // TODO: generalize this function so that when @@ -99,7 +100,7 @@ bool GrClipMaskManager::useSWOnlyPath(const GrDrawState* drawState, if (Element::kRect_Type != element->getType()) { SkPath path; element->asPath(&path); - if (path_needs_SW_renderer(this->getContext(), fClipTarget, drawState, translate, + if (path_needs_SW_renderer(this->getContext(), fClipTarget, pipelineBuilder, translate, path, stroke, element->isAA())) { return true; } @@ -108,8 +109,8 @@ bool GrClipMaskManager::useSWOnlyPath(const GrDrawState* drawState, return false; } -bool GrClipMaskManager::installClipEffects(GrDrawState* drawState, - GrDrawState::AutoRestoreEffects* are, +bool GrClipMaskManager::installClipEffects(GrPipelineBuilder* pipelineBuilder, + GrPipelineBuilder::AutoRestoreEffects* are, const GrReducedClip::ElementList& elements, const SkVector& clipToRTOffset, const SkRect* drawBounds) { @@ -119,8 +120,8 @@ bool GrClipMaskManager::installClipEffects(GrDrawState* drawState, boundsInClipSpace.offset(-clipToRTOffset.fX, -clipToRTOffset.fY); } - are->set(drawState); - GrRenderTarget* rt = drawState->getRenderTarget(); + are->set(pipelineBuilder); + GrRenderTarget* rt = pipelineBuilder->getRenderTarget(); GrReducedClip::ElementList::Iter iter(elements); bool failed = false; while (iter.get()) { @@ -186,7 +187,7 @@ bool GrClipMaskManager::installClipEffects(GrDrawState* drawState, break; } if (fp) { - drawState->addCoverageProcessor(fp); + pipelineBuilder->addCoverageProcessor(fp); } else { failed = true; break; @@ -204,9 +205,9 @@ bool GrClipMaskManager::installClipEffects(GrDrawState* drawState, //////////////////////////////////////////////////////////////////////////////// // sort out what kind of clip mask needs to be created: alpha, stencil, // scissor, or entirely software -bool GrClipMaskManager::setupClipping(GrDrawState* drawState, - GrDrawState::AutoRestoreEffects* are, - GrDrawState::AutoRestoreStencil* ars, +bool GrClipMaskManager::setupClipping(GrPipelineBuilder* pipelineBuilder, + GrPipelineBuilder::AutoRestoreEffects* are, + GrPipelineBuilder::AutoRestoreStencil* ars, GrScissorState* scissorState, const GrClipData* clipDataIn, const SkRect* devBounds) { @@ -220,12 +221,12 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, GrReducedClip::InitialState initialState; SkIRect clipSpaceIBounds; bool requiresAA; - GrRenderTarget* rt = drawState->getRenderTarget(); + GrRenderTarget* rt = pipelineBuilder->getRenderTarget(); // GrDrawTarget should have filtered this for us SkASSERT(rt); - bool ignoreClip = !drawState->isClipState() || clipDataIn->fClipStack->isWideOpen(); + bool ignoreClip = !pipelineBuilder->isClipState() || clipDataIn->fClipStack->isWideOpen(); if (!ignoreClip) { SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height()); clipSpaceRTIBounds.offset(clipDataIn->fOrigin); @@ -246,7 +247,7 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, } if (ignoreClip) { - this->setDrawStateStencil(drawState, ars); + this->setPipelineBuilderStencil(pipelineBuilder, ars); return true; } @@ -262,7 +263,7 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, SkVector clipToRTOffset = { SkIntToScalar(-clipDataIn->fOrigin.fX), SkIntToScalar(-clipDataIn->fOrigin.fY) }; if (elements.isEmpty() || - (requiresAA && this->installClipEffects(drawState, are, elements, clipToRTOffset, + (requiresAA && this->installClipEffects(pipelineBuilder, are, elements, clipToRTOffset, devBounds))) { SkIRect scissorSpaceIBounds(clipSpaceIBounds); scissorSpaceIBounds.offset(-clipDataIn->fOrigin); @@ -270,7 +271,7 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) { scissorState->set(scissorSpaceIBounds); } - this->setDrawStateStencil(drawState, ars); + this->setPipelineBuilderStencil(pipelineBuilder, ars); return true; } } @@ -286,7 +287,7 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, SkIntToScalar(-clipSpaceIBounds.fTop) }; - if (this->useSWOnlyPath(drawState, clipToMaskOffset, elements)) { + if (this->useSWOnlyPath(pipelineBuilder, clipToMaskOffset, elements)) { // The clip geometry is complex enough that it will be more efficient to create it // entirely in software result = this->createSoftwareClipMask(genID, @@ -307,8 +308,8 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, // clipSpace bounds. We determine the mask's position WRT to the render target here. SkIRect rtSpaceMaskBounds = clipSpaceIBounds; rtSpaceMaskBounds.offset(-clipDataIn->fOrigin); - setup_drawstate_aaclip(rtSpaceMaskBounds, drawState, result); - this->setDrawStateStencil(drawState, ars); + setup_drawstate_aaclip(rtSpaceMaskBounds, pipelineBuilder, result); + this->setPipelineBuilderStencil(pipelineBuilder, ars); return true; } // if alpha clip mask creation fails fall through to the non-AA code paths @@ -337,28 +338,29 @@ bool GrClipMaskManager::setupClipping(GrDrawState* drawState, SkIRect scissorSpaceIBounds(clipSpaceIBounds); scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset); scissorState->set(scissorSpaceIBounds); - this->setDrawStateStencil(drawState, ars); + this->setPipelineBuilderStencil(pipelineBuilder, ars); return true; } namespace { //////////////////////////////////////////////////////////////////////////////// -// Set a coverage drawing XPF on the drawState for the given op and invertCoverage mode -void set_coverage_drawing_xpf(SkRegion::Op op, bool invertCoverage, GrDrawState* drawState) { +// Set a coverage drawing XPF on the pipelineBuilder for the given op and invertCoverage mode +void set_coverage_drawing_xpf(SkRegion::Op op, bool invertCoverage, + GrPipelineBuilder* pipelineBuilder) { SkASSERT(op <= SkRegion::kLastOp); - drawState->setCoverageSetOpXPFactory(op, invertCoverage); + pipelineBuilder->setCoverageSetOpXPFactory(op, invertCoverage); } } //////////////////////////////////////////////////////////////////////////////// -bool GrClipMaskManager::drawElement(GrDrawState* drawState, +bool GrClipMaskManager::drawElement(GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, GrTexture* target, const SkClipStack::Element* element, GrPathRenderer* pr) { GrDrawTarget::AutoGeometryPush agp(fClipTarget); - drawState->setRenderTarget(target->asRenderTarget()); + pipelineBuilder->setRenderTarget(target->asRenderTarget()); // The color we use to draw does not matter since we will always be using a GrCoverageSetOpXP // which ignores color. @@ -376,13 +378,13 @@ bool GrClipMaskManager::drawElement(GrDrawState* drawState, SkRect devRect = element->getRect(); viewMatrix.mapRect(&devRect); this->getContext()->getAARectRenderer()->fillAARect(fClipTarget, - drawState, + pipelineBuilder, color, viewMatrix, element->getRect(), devRect); } else { - fClipTarget->drawSimpleRect(drawState, color, viewMatrix, element->getRect()); + fClipTarget->drawSimpleRect(pipelineBuilder, color, viewMatrix, element->getRect()); } return true; default: { @@ -397,25 +399,26 @@ bool GrClipMaskManager::drawElement(GrDrawState* drawState, GrPathRendererChain::DrawType type; type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType : GrPathRendererChain::kColor_DrawType; - pr = this->getContext()->getPathRenderer(fClipTarget, drawState, viewMatrix, path, - stroke, false, type); + pr = this->getContext()->getPathRenderer(fClipTarget, pipelineBuilder, viewMatrix, + path, stroke, false, type); } if (NULL == pr) { return false; } - pr->drawPath(fClipTarget, drawState, color, viewMatrix, path, stroke, element->isAA()); + pr->drawPath(fClipTarget, pipelineBuilder, color, viewMatrix, path, stroke, + element->isAA()); break; } } return true; } -bool GrClipMaskManager::canStencilAndDrawElement(GrDrawState* drawState, +bool GrClipMaskManager::canStencilAndDrawElement(GrPipelineBuilder* pipelineBuilder, GrTexture* target, GrPathRenderer** pr, const SkClipStack::Element* element) { - drawState->setRenderTarget(target->asRenderTarget()); + pipelineBuilder->setRenderTarget(target->asRenderTarget()); if (Element::kRect_Type == element->getType()) { return true; @@ -431,34 +434,35 @@ bool GrClipMaskManager::canStencilAndDrawElement(GrDrawState* drawState, GrPathRendererChain::DrawType type = element->isAA() ? GrPathRendererChain::kStencilAndColorAntiAlias_DrawType : GrPathRendererChain::kStencilAndColor_DrawType; - *pr = this->getContext()->getPathRenderer(fClipTarget, drawState, SkMatrix::I(), path, + *pr = this->getContext()->getPathRenderer(fClipTarget, pipelineBuilder, SkMatrix::I(), path, stroke, false, type); return SkToBool(*pr); } } -void GrClipMaskManager::mergeMask(GrDrawState* drawState, +void GrClipMaskManager::mergeMask(GrPipelineBuilder* pipelineBuilder, GrTexture* dstMask, GrTexture* srcMask, SkRegion::Op op, const SkIRect& dstBound, const SkIRect& srcBound) { - drawState->setRenderTarget(dstMask->asRenderTarget()); + pipelineBuilder->setRenderTarget(dstMask->asRenderTarget()); // We want to invert the coverage here - set_coverage_drawing_xpf(op, false, drawState); + set_coverage_drawing_xpf(op, false, pipelineBuilder); SkMatrix sampleM; sampleM.setIDiv(srcMask->width(), srcMask->height()); - drawState->addCoverageProcessor( + pipelineBuilder->addCoverageProcessor( GrTextureDomainEffect::Create(srcMask, sampleM, GrTextureDomain::MakeTexelDomain(srcMask, srcBound), GrTextureDomain::kDecal_Mode, GrTextureParams::kNone_FilterMode))->unref(); // The color passed in here does not matter since the coverageSetOpXP won't read it. - fClipTarget->drawSimpleRect(drawState, GrColor_WHITE, SkMatrix::I(), SkRect::Make(dstBound)); + fClipTarget->drawSimpleRect(pipelineBuilder, GrColor_WHITE, SkMatrix::I(), + SkRect::Make(dstBound)); } GrTexture* GrClipMaskManager::createTempMask(int width, int height) { @@ -563,11 +567,11 @@ GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID, SkRegion::Op op = element->getOp(); bool invert = element->isInverseFilled(); if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) { - GrDrawState drawState; - drawState.enableState(GrDrawState::kClip_StateBit); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.enableState(GrPipelineBuilder::kClip_StateBit); GrPathRenderer* pr = NULL; - bool useTemp = !this->canStencilAndDrawElement(&drawState, result, &pr, element); + bool useTemp = !this->canStencilAndDrawElement(&pipelineBuilder, result, &pr, element); GrTexture* dst; // This is the bounds of the clip element in the space of the alpha-mask. The temporary // mask buffer can be substantially larger than the actually clip stack element. We @@ -598,7 +602,7 @@ GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID, invert ? 0xffffffff : 0x00000000, true, dst->asRenderTarget()); - set_coverage_drawing_xpf(SkRegion::kReplace_Op, invert, &drawState); + set_coverage_drawing_xpf(SkRegion::kReplace_Op, invert, &pipelineBuilder); } else { // draw directly into the result with the stencil set to make the pixels affected // by the clip shape be non-zero. @@ -610,34 +614,34 @@ GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID, 0xffff, 0xffff, 0xffff); - drawState.setStencil(kStencilInElement); - set_coverage_drawing_xpf(op, invert, &drawState); + pipelineBuilder.setStencil(kStencilInElement); + set_coverage_drawing_xpf(op, invert, &pipelineBuilder); } - if (!this->drawElement(&drawState, translate, dst, element, pr)) { + if (!this->drawElement(&pipelineBuilder, translate, dst, element, pr)) { fAACache.reset(); return NULL; } if (useTemp) { - GrDrawState backgroundDrawState; - backgroundDrawState.enableState(GrDrawState::kClip_StateBit); - backgroundDrawState.setRenderTarget(result->asRenderTarget()); + GrPipelineBuilder backgroundPipelineBuilder; + backgroundPipelineBuilder.enableState(GrPipelineBuilder::kClip_StateBit); + backgroundPipelineBuilder.setRenderTarget(result->asRenderTarget()); // Now draw into the accumulator using the real operation and the temp buffer as a // texture - this->mergeMask(&backgroundDrawState, + this->mergeMask(&backgroundPipelineBuilder, result, temp, op, maskSpaceIBounds, maskSpaceElementIBounds); } else { - GrDrawState backgroundDrawState; - backgroundDrawState.enableState(GrDrawState::kClip_StateBit); - backgroundDrawState.setRenderTarget(result->asRenderTarget()); + GrPipelineBuilder backgroundPipelineBuilder; + backgroundPipelineBuilder.enableState(GrPipelineBuilder::kClip_StateBit); + backgroundPipelineBuilder.setRenderTarget(result->asRenderTarget()); - set_coverage_drawing_xpf(op, !invert, &backgroundDrawState); + set_coverage_drawing_xpf(op, !invert, &backgroundPipelineBuilder); // Draw to the exterior pixels (those with a zero stencil value). GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement, kZero_StencilOp, @@ -646,19 +650,19 @@ GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID, 0xffff, 0x0000, 0xffff); - backgroundDrawState.setStencil(kDrawOutsideElement); + backgroundPipelineBuilder.setStencil(kDrawOutsideElement); // The color passed in here does not matter since the coverageSetOpXP won't read it. - fClipTarget->drawSimpleRect(&backgroundDrawState, GrColor_WHITE, translate, + fClipTarget->drawSimpleRect(&backgroundPipelineBuilder, GrColor_WHITE, translate, clipSpaceIBounds); } } else { - GrDrawState drawState; - drawState.enableState(GrDrawState::kClip_StateBit); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.enableState(GrPipelineBuilder::kClip_StateBit); // all the remaining ops can just be directly draw into the accumulation buffer - set_coverage_drawing_xpf(op, false, &drawState); + set_coverage_drawing_xpf(op, false, &pipelineBuilder); // The color passed in here does not matter since the coverageSetOpXP won't read it. - this->drawElement(&drawState, translate, result, element); + this->drawElement(&pipelineBuilder, translate, result, element); } } @@ -712,15 +716,15 @@ bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt, for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) { const Element* element = iter.get(); - GrDrawState drawState; - drawState.setRenderTarget(rt); - drawState.enableState(GrDrawState::kClip_StateBit); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(rt); + pipelineBuilder.enableState(GrPipelineBuilder::kClip_StateBit); - drawState.setDisableColorXPFactory(); + pipelineBuilder.setDisableColorXPFactory(); // if the target is MSAA then we want MSAA enabled when the clip is soft if (rt->isMultisampled()) { - drawState.setState(GrDrawState::kHWAntialias_StateBit, element->isAA()); + pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_StateBit, element->isAA()); } bool fillInverted = false; @@ -746,7 +750,7 @@ bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt, clipPath.toggleInverseFillType(); } pr = this->getContext()->getPathRenderer(fClipTarget, - &drawState, + &pipelineBuilder, viewMatrix, clipPath, stroke, @@ -784,18 +788,19 @@ bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt, 0x0000, 0xffff); if (Element::kRect_Type == element->getType()) { - *drawState.stencil() = gDrawToStencil; - fClipTarget->drawSimpleRect(&drawState, GrColor_WHITE, viewMatrix, + *pipelineBuilder.stencil() = gDrawToStencil; + fClipTarget->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, viewMatrix, element->getRect()); } else { if (!clipPath.isEmpty()) { GrDrawTarget::AutoGeometryPush agp(fClipTarget); if (canRenderDirectToStencil) { - *drawState.stencil() = gDrawToStencil; - pr->drawPath(fClipTarget, &drawState, GrColor_WHITE, viewMatrix, + *pipelineBuilder.stencil() = gDrawToStencil; + pr->drawPath(fClipTarget, &pipelineBuilder, GrColor_WHITE, viewMatrix, clipPath, stroke, false); } else { - pr->stencilPath(fClipTarget, &drawState, viewMatrix, clipPath, stroke); + pr->stencilPath(fClipTarget, &pipelineBuilder, viewMatrix, clipPath, + stroke); } } } @@ -805,22 +810,22 @@ bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt, // element directly or a bounding rect of the entire clip. fClipMode = kModifyClip_StencilClipMode; for (int p = 0; p < passes; ++p) { - GrDrawState drawStateCopy(drawState); - *drawStateCopy.stencil() = stencilSettings[p]; + GrPipelineBuilder pipelineBuilderCopy(pipelineBuilder); + *pipelineBuilderCopy.stencil() = stencilSettings[p]; if (canDrawDirectToClip) { if (Element::kRect_Type == element->getType()) { - fClipTarget->drawSimpleRect(&drawStateCopy, GrColor_WHITE, viewMatrix, + fClipTarget->drawSimpleRect(&pipelineBuilderCopy, GrColor_WHITE, viewMatrix, element->getRect()); } else { GrDrawTarget::AutoGeometryPush agp(fClipTarget); - pr->drawPath(fClipTarget, &drawStateCopy, GrColor_WHITE, viewMatrix, + pr->drawPath(fClipTarget, &pipelineBuilderCopy, GrColor_WHITE, viewMatrix, clipPath, stroke, false); } } else { // The view matrix is setup to do clip space -> stencil space translation, so // draw rect in clip space. - fClipTarget->drawSimpleRect(&drawStateCopy, GrColor_WHITE, viewMatrix, + fClipTarget->drawSimpleRect(&pipelineBuilderCopy, GrColor_WHITE, viewMatrix, SkRect::Make(clipSpaceIBounds)); } } @@ -885,8 +890,8 @@ const GrStencilSettings& basic_apply_stencil_clip_settings() { } } -void GrClipMaskManager::setDrawStateStencil(GrDrawState* drawState, - GrDrawState::AutoRestoreStencil* ars) { +void GrClipMaskManager::setPipelineBuilderStencil(GrPipelineBuilder* pipelineBuilder, + GrPipelineBuilder::AutoRestoreStencil* ars) { // We make two copies of the StencilSettings here (except in the early // exit scenario. One copy from draw state to the stack var. Then another // from the stack var to the gpu. We could make this class hold a ptr to @@ -898,19 +903,19 @@ void GrClipMaskManager::setDrawStateStencil(GrDrawState* drawState, // The GrGpu client may not be using the stencil buffer but we may need to // enable it in order to respect a stencil clip. - if (drawState->getStencil().isDisabled()) { + if (pipelineBuilder->getStencil().isDisabled()) { if (GrClipMaskManager::kRespectClip_StencilClipMode == fClipMode) { settings = basic_apply_stencil_clip_settings(); } else { return; } } else { - settings = drawState->getStencil(); + settings = pipelineBuilder->getStencil(); } // TODO: dynamically attach a stencil buffer int stencilBits = 0; - GrStencilBuffer* stencilBuffer = drawState->getRenderTarget()->getStencilBuffer(); + GrStencilBuffer* stencilBuffer = pipelineBuilder->getRenderTarget()->getStencilBuffer(); if (stencilBuffer) { stencilBits = stencilBuffer->bits(); } @@ -918,8 +923,8 @@ void GrClipMaskManager::setDrawStateStencil(GrDrawState* drawState, SkASSERT(fClipTarget->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp()); SkASSERT(fClipTarget->caps()->twoSidedStencilSupport() || !settings.isTwoSided()); this->adjustStencilParams(&settings, fClipMode, stencilBits); - ars->set(drawState); - drawState->setStencil(settings); + ars->set(pipelineBuilder); + pipelineBuilder->setStencil(settings); } void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings, diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h index fef47e4c3c..ed3d431268 100644 --- a/src/gpu/GrClipMaskManager.h +++ b/src/gpu/GrClipMaskManager.h @@ -9,7 +9,7 @@ #include "GrClipMaskCache.h" #include "GrContext.h" -#include "GrDrawState.h" +#include "GrPipelineBuilder.h" #include "GrReducedClip.h" #include "GrStencil.h" #include "GrTexture.h" @@ -48,9 +48,9 @@ public: * the manager when it must install additional effects to implement the * clip. devBounds is optional but can help optimize clipping. */ - bool setupClipping(GrDrawState*, - GrDrawState::AutoRestoreEffects*, - GrDrawState::AutoRestoreStencil*, + bool setupClipping(GrPipelineBuilder*, + GrPipelineBuilder::AutoRestoreEffects*, + GrPipelineBuilder::AutoRestoreStencil*, GrScissorState*, const GrClipData* clipDataIn, const SkRect* devBounds); @@ -94,8 +94,8 @@ private: // Attempts to install a series of coverage effects to implement the clip. Return indicates // whether the element list was successfully converted to effects. - bool installClipEffects(GrDrawState*, - GrDrawState::AutoRestoreEffects*, + bool installClipEffects(GrPipelineBuilder*, + GrPipelineBuilder::AutoRestoreEffects*, const GrReducedClip::ElementList&, const SkVector& clipOffset, const SkRect* devBounds); @@ -133,14 +133,14 @@ private: const SkIRect& clipSpaceIBounds, bool willUpload); - bool useSWOnlyPath(const GrDrawState*, + bool useSWOnlyPath(const GrPipelineBuilder*, const SkVector& clipToMaskOffset, const GrReducedClip::ElementList& elements); // Draws a clip element into the target alpha mask. The caller should have already setup the // desired blend operation. Optionally if the caller already selected a path renderer it can // be passed. Otherwise the function will select one if the element is a path. - bool drawElement(GrDrawState*, + bool drawElement(GrPipelineBuilder*, const SkMatrix& viewMatrix, GrTexture* target, const SkClipStack::Element*, @@ -149,12 +149,12 @@ private: // Determines whether it is possible to draw the element to both the stencil buffer and the // alpha mask simultaneously. If so and the element is a path a compatible path renderer is // also returned. - bool canStencilAndDrawElement(GrDrawState*, + bool canStencilAndDrawElement(GrPipelineBuilder*, GrTexture* target, GrPathRenderer**, const SkClipStack::Element*); - void mergeMask(GrDrawState*, + void mergeMask(GrPipelineBuilder*, GrTexture* dstMask, GrTexture* srcMask, SkRegion::Op op, @@ -170,7 +170,7 @@ private: * updates the GrGpu with stencil settings that account stencil-based * clipping. */ - void setDrawStateStencil(GrDrawState*, GrDrawState::AutoRestoreStencil*); + void setPipelineBuilderStencil(GrPipelineBuilder*, GrPipelineBuilder::AutoRestoreStencil*); /** * Adjusts the stencil settings to account for interaction with stencil diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index a0fc678a40..b798ef0478 100755 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -294,8 +294,8 @@ GrTexture* GrContext::createResizedTexture(const GrSurfaceDesc& desc, GrTexture* texture = fGpu->createTexture(rtDesc, true, NULL, 0); if (texture) { - GrDrawState drawState; - drawState.setRenderTarget(texture->asRenderTarget()); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(texture->asRenderTarget()); // if filtering is not desired then we want to ensure all // texels in the resampled image are copies of texels from @@ -303,7 +303,7 @@ GrTexture* GrContext::createResizedTexture(const GrSurfaceDesc& desc, GrTextureParams params(SkShader::kClamp_TileMode, filter ? GrTextureParams::kBilerp_FilterMode : GrTextureParams::kNone_FilterMode); - drawState.addColorTextureProcessor(clampedTexture, SkMatrix::I(), params); + pipelineBuilder.addColorTextureProcessor(clampedTexture, SkMatrix::I(), params); uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType | GrDefaultGeoProcFactory::kLocalCoord_GPType; @@ -317,7 +317,7 @@ GrTexture* GrContext::createResizedTexture(const GrSurfaceDesc& desc, SkPoint* verts = (SkPoint*) arg.vertices(); verts[0].setIRectFan(0, 0, texture->width(), texture->height(), 2 * sizeof(SkPoint)); verts[1].setIRectFan(0, 0, 1, 1, 2 * sizeof(SkPoint)); - fDrawBuffer->drawNonIndexed(&drawState, gp, kTriangleFan_GrPrimitiveType, 0, 4); + fDrawBuffer->drawNonIndexed(&pipelineBuilder, gp, kTriangleFan_GrPrimitiveType, 0, 4); } } else { // TODO: Our CPU stretch doesn't filter. But we create separate @@ -571,14 +571,14 @@ void GrContext::drawPaint(const GrPaint& origPaint, const SkMatrix& viewMatrix) } AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, paint, &acf); if (NULL == target) { return; } GR_CREATE_TRACE_MARKER("GrContext::drawPaintWithPerspective", target); - target->drawRect(&drawState, paint->getColor(), SkMatrix::I(), r, NULL, &localMatrix); + target->drawRect(&pipelineBuilder, paint->getColor(), SkMatrix::I(), r, NULL, &localMatrix); } } @@ -618,21 +618,21 @@ static inline bool is_irect(const SkRect& r) { } static bool apply_aa_to_rect(GrDrawTarget* target, - GrDrawState* ds, + GrPipelineBuilder* pipelineBuilder, SkRect* devBoundRect, const SkRect& rect, SkScalar strokeWidth, const SkMatrix& combinedMatrix, GrColor color) { - if (!ds->canTweakAlphaForCoverage() && !ds->canUseFracCoveragePrimProc(color, - *target->caps())) { + if (!pipelineBuilder->canTweakAlphaForCoverage() && + !pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps())) { #ifdef SK_DEBUG //SkDebugf("Turning off AA to correctly apply blend.\n"); #endif return false; } - if (ds->getRenderTarget()->isMultisampled()) { + if (pipelineBuilder->getRenderTarget()->isMultisampled()) { return false; } @@ -680,8 +680,8 @@ void GrContext::drawRect(const GrPaint& paint, } AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } @@ -693,7 +693,7 @@ void GrContext::drawRect(const GrPaint& paint, // cases where the RT is fully inside a stroke. if (width < 0) { SkRect rtRect; - drawState.getRenderTarget()->getBoundsRect(&rtRect); + pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect); SkRect clipSpaceRTRect = rtRect; bool checkClip = false; if (this->getClip()) { @@ -726,15 +726,15 @@ void GrContext::drawRect(const GrPaint& paint, GrColor color = paint.getColor(); SkRect devBoundRect; - bool needAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled(); - bool doAA = needAA && apply_aa_to_rect(target, &drawState, &devBoundRect, rect, width, + bool needAA = paint.isAntiAlias() && !pipelineBuilder.getRenderTarget()->isMultisampled(); + bool doAA = needAA && apply_aa_to_rect(target, &pipelineBuilder, &devBoundRect, rect, width, viewMatrix, color); if (doAA) { if (width >= 0) { const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec(); fAARectRenderer->strokeAARect(target, - &drawState, + &pipelineBuilder, color, viewMatrix, rect, @@ -743,7 +743,7 @@ void GrContext::drawRect(const GrPaint& paint, } else { // filled AA rect fAARectRenderer->fillAARect(target, - &drawState, + &pipelineBuilder, color, viewMatrix, rect, @@ -793,10 +793,10 @@ void GrContext::drawRect(const GrPaint& paint, vertex[4].set(rect.fLeft, rect.fTop); } - target->drawNonIndexed(&drawState, gp, primType, 0, vertCount); + target->drawNonIndexed(&pipelineBuilder, gp, primType, 0, vertCount); } else { // filled BW rect - target->drawSimpleRect(&drawState, color, viewMatrix, rect); + target->drawSimpleRect(&pipelineBuilder, color, viewMatrix, rect); } } @@ -806,15 +806,16 @@ void GrContext::drawNonAARectToRect(const GrPaint& paint, const SkRect& localRect, const SkMatrix* localMatrix) { AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target); - target->drawRect(&drawState, paint.getColor(), viewMatrix, rectToDraw, &localRect, localMatrix); + target->drawRect(&pipelineBuilder, paint.getColor(), viewMatrix, rectToDraw, &localRect, + localMatrix); } static const GrGeometryProcessor* set_vertex_attributes(const SkPoint* texCoords, @@ -851,10 +852,10 @@ void GrContext::drawVertices(const GrPaint& paint, const uint16_t indices[], int indexCount) { AutoCheckFlush acf(this); - GrDrawState drawState; + GrPipelineBuilder pipelineBuilder; GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } @@ -894,9 +895,9 @@ void GrContext::drawVertices(const GrPaint& paint, for (int i = 0; i < indexCount; ++i) { curIndex[i] = indices[i]; } - target->drawIndexed(&drawState, gp, primitiveType, 0, 0, vertexCount, indexCount); + target->drawIndexed(&pipelineBuilder, gp, primitiveType, 0, 0, vertexCount, indexCount); } else { - target->drawNonIndexed(&drawState, gp, primitiveType, 0, vertexCount); + target->drawNonIndexed(&pipelineBuilder, gp, primitiveType, 0, vertexCount); } } @@ -918,8 +919,8 @@ void GrContext::drawRRect(const GrPaint& paint, } AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } @@ -929,12 +930,12 @@ void GrContext::drawRRect(const GrPaint& paint, const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec(); GrColor color = paint.getColor(); - if (!fOvalRenderer->drawRRect(target, &drawState, color, viewMatrix, paint.isAntiAlias(), rrect, - strokeRec)) { + if (!fOvalRenderer->drawRRect(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(), + rrect, strokeRec)) { SkPath path; path.addRRect(rrect); - this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path, - strokeInfo); + this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(), + path, strokeInfo); } } @@ -949,21 +950,22 @@ void GrContext::drawDRRect(const GrPaint& paint, } AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target); GrColor color = paint.getColor(); - if (!fOvalRenderer->drawDRRect(target, &drawState, color, viewMatrix, paint.isAntiAlias(), outer, inner)) { + if (!fOvalRenderer->drawDRRect(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(), + outer, inner)) { SkPath path; path.addRRect(inner); path.addRRect(outer); path.setFillType(SkPath::kEvenOdd_FillType); GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle); - this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path, - fillRec); + this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(), + path, fillRec); } } @@ -985,8 +987,8 @@ void GrContext::drawOval(const GrPaint& paint, } AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } @@ -996,18 +998,18 @@ void GrContext::drawOval(const GrPaint& paint, const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec(); GrColor color = paint.getColor(); - if (!fOvalRenderer->drawOval(target, &drawState, color, viewMatrix, paint.isAntiAlias(), oval, - strokeRec)) { + if (!fOvalRenderer->drawOval(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(), + oval, strokeRec)) { SkPath path; path.addOval(oval); - this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path, - strokeInfo); + this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(), + path, strokeInfo); } } // Can 'path' be drawn as a pair of filled nested rectangles? static bool is_nested_rects(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -1025,8 +1027,8 @@ static bool is_nested_rects(GrDrawTarget* target, return false; } - if (!drawState->canTweakAlphaForCoverage() && - !drawState->canUseFracCoveragePrimProc(color, *target->caps())) { + if (!pipelineBuilder->canTweakAlphaForCoverage() && + !pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps())) { return false; } @@ -1080,14 +1082,14 @@ void GrContext::drawPath(const GrPaint& paint, SkPoint pts[2]; if (path.isLine(pts)) { AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } - if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, color, viewMatrix, pts, - paint, strokeInfo)) { + if (GrDashingEffect::DrawDashLine(fGpu, target, &pipelineBuilder, color, viewMatrix, + pts, paint, strokeInfo)) { return; } } @@ -1112,8 +1114,8 @@ void GrContext::drawPath(const GrPaint& paint, // the writePixels that uploads to the scratch will perform a flush so we're // OK. AutoCheckFlush acf(this); - GrDrawState drawState; - GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf); + GrPipelineBuilder pipelineBuilder; + GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, &paint, &acf); if (NULL == target) { return; } @@ -1122,14 +1124,15 @@ void GrContext::drawPath(const GrPaint& paint, const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec(); - bool useCoverageAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled(); + bool useCoverageAA = paint.isAntiAlias() && + !pipelineBuilder.getRenderTarget()->isMultisampled(); if (useCoverageAA && strokeRec.getWidth() < 0 && !path.isConvex()) { // Concave AA paths are expensive - try to avoid them for special cases SkRect rects[2]; - if (is_nested_rects(target, &drawState, color, viewMatrix, path, strokeRec, rects)) { - fAARectRenderer->fillAANestedRects(target, &drawState, color, viewMatrix,rects); + if (is_nested_rects(target, &pipelineBuilder, color, viewMatrix, path, strokeRec, rects)) { + fAARectRenderer->fillAANestedRects(target, &pipelineBuilder, color, viewMatrix,rects); return; } } @@ -1138,15 +1141,15 @@ void GrContext::drawPath(const GrPaint& paint, bool isOval = path.isOval(&ovalRect); if (!isOval || path.isInverseFillType() || - !fOvalRenderer->drawOval(target, &drawState, color, viewMatrix, paint.isAntiAlias(), + !fOvalRenderer->drawOval(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(), ovalRect, strokeRec)) { - this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path, - strokeInfo); + this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(), + path, strokeInfo); } } void GrContext::internalDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, GrColor color, bool useAA, @@ -1162,8 +1165,8 @@ void GrContext::internalDrawPath(GrDrawTarget* target, // aa. If we have some future driver-mojo path AA that can do the right // thing WRT to the blend then we'll need some query on the PR. bool useCoverageAA = useAA && - !drawState->getRenderTarget()->isMultisampled() && - drawState->canUseFracCoveragePrimProc(color, *target->caps()); + !pipelineBuilder->getRenderTarget()->isMultisampled() && + pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps()); GrPathRendererChain::DrawType type = @@ -1175,8 +1178,8 @@ void GrContext::internalDrawPath(GrDrawTarget* target, SkTCopyOnFirstWrite<SkStrokeRec> stroke(strokeInfo.getStrokeRec()); // Try a 1st time without stroking the path and without allowing the SW renderer - GrPathRenderer* pr = this->getPathRenderer(target, drawState, viewMatrix, *pathPtr, *stroke, - false, type); + GrPathRenderer* pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, + *stroke, false, type); if (NULL == pr) { if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, viewMatrix, NULL)) { @@ -1191,7 +1194,8 @@ void GrContext::internalDrawPath(GrDrawTarget* target, } // This time, allow SW renderer - pr = this->getPathRenderer(target, drawState, viewMatrix, *pathPtr, *stroke, true, type); + pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *stroke, true, + type); } if (NULL == pr) { @@ -1201,7 +1205,7 @@ void GrContext::internalDrawPath(GrDrawTarget* target, return; } - pr->drawPath(target, drawState, color, viewMatrix, *pathPtr, *stroke, useCoverageAA); + pr->drawPath(target, pipelineBuilder, color, viewMatrix, *pathPtr, *stroke, useCoverageAA); } //////////////////////////////////////////////////////////////////////////////// @@ -1339,10 +1343,10 @@ bool GrContext::writeSurfacePixels(GrSurface* surface, GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL); GrDrawTarget::AutoGeometryPush agp(drawTarget); - GrDrawState drawState; - drawState.addColorProcessor(fp); - drawState.setRenderTarget(renderTarget); - drawTarget->drawSimpleRect(&drawState, GrColor_WHITE, matrix, + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.addColorProcessor(fp); + pipelineBuilder.setRenderTarget(renderTarget); + drawTarget->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, matrix, SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height))); } @@ -1458,13 +1462,14 @@ bool GrContext::readRenderTargetPixels(GrRenderTarget* target, // can be invoked in this method { GrDrawTarget::AutoGeometryPush agp(fDrawBuffer); - GrDrawState drawState; + GrPipelineBuilder pipelineBuilder; SkASSERT(fp); - drawState.addColorProcessor(fp); + pipelineBuilder.addColorProcessor(fp); - drawState.setRenderTarget(tempTexture->asRenderTarget()); + pipelineBuilder.setRenderTarget(tempTexture->asRenderTarget()); SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)); - fDrawBuffer->drawSimpleRect(&drawState, GrColor_WHITE, SkMatrix::I(), rect); + fDrawBuffer->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, SkMatrix::I(), + rect); // we want to read back from the scratch's origin left = 0; top = 0; @@ -1552,7 +1557,7 @@ void GrContext::flushSurfaceWrites(GrSurface* surface) { } } -GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds, +GrDrawTarget* GrContext::prepareToDraw(GrPipelineBuilder* pipelineBuilder, const GrPaint* paint, const AutoCheckFlush* acf) { if (NULL == fGpu) { @@ -1560,10 +1565,11 @@ GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds, } ASSERT_OWNED_RESOURCE(fRenderTarget.get()); - if (ds) { + if (pipelineBuilder) { SkASSERT(paint && acf); - ds->setFromPaint(*paint, fRenderTarget.get()); - ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen()); + pipelineBuilder->setFromPaint(*paint, fRenderTarget.get()); + pipelineBuilder->setState(GrPipelineBuilder::kClip_StateBit, + fClip && !fClip->fClipStack->isWideOpen()); } fDrawBuffer->setClip(fClip); return fDrawBuffer; @@ -1576,7 +1582,7 @@ GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds, * can be individually allowed/disallowed via the "allowSW" boolean. */ GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -1589,7 +1595,7 @@ GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target, } GrPathRenderer* pr = fPathRendererChain->getPathRenderer(target, - drawState, + pipelineBuilder, viewMatrix, path, stroke, diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp index 3e32e65c62..20ec66553c 100644 --- a/src/gpu/GrDefaultGeoProcFactory.cpp +++ b/src/gpu/GrDefaultGeoProcFactory.cpp @@ -7,7 +7,6 @@ #include "GrDefaultGeoProcFactory.h" -#include "GrDrawState.h" #include "GrInvariantOutput.h" #include "gl/GrGLGeometryProcessor.h" #include "gl/builders/GrGLProgramBuilder.h" diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp index af0404ae0e..7b9817484f 100644 --- a/src/gpu/GrDefaultPathRenderer.cpp +++ b/src/gpu/GrDefaultPathRenderer.cpp @@ -9,8 +9,8 @@ #include "GrContext.h" #include "GrDefaultGeoProcFactory.h" -#include "GrDrawState.h" #include "GrPathUtils.h" +#include "GrPipelineBuilder.h" #include "SkGeometry.h" #include "SkString.h" #include "SkStrokeRec.h" @@ -165,7 +165,7 @@ static inline bool single_pass_path(const SkPath& path, const SkStrokeRec& strok GrPathRenderer::StencilSupport GrDefaultPathRenderer::onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath& path, const SkStrokeRec& stroke) const { if (single_pass_path(path, stroke)) { @@ -208,7 +208,7 @@ static inline void add_quad(SkPoint** vert, const SkPoint* base, const SkPoint p } bool GrDefaultPathRenderer::createGeom(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrPrimitiveType* primType, int* vertexCnt, int* indexCnt, @@ -342,7 +342,7 @@ FINISHED: } bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -368,7 +368,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, GrPrimitiveType primType; GrDrawTarget::AutoReleaseGeometry arg; if (!this->createGeom(target, - drawState, + pipelineBuilder, &primType, &vertexCnt, &indexCnt, @@ -379,13 +379,13 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, return false; } // Save the current xp on the draw state so we can reset it if needed - SkAutoTUnref<const GrXPFactory> backupXPFactory(SkRef(drawState->getXPFactory())); + SkAutoTUnref<const GrXPFactory> backupXPFactory(SkRef(pipelineBuilder->getXPFactory())); // face culling doesn't make sense here - SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace()); + SkASSERT(GrPipelineBuilder::kBoth_DrawFace == pipelineBuilder->getDrawFace()); int passCount = 0; const GrStencilSettings* passes[3]; - GrDrawState::DrawFace drawFace[3]; + GrPipelineBuilder::DrawFace drawFace[3]; bool reverse = false; bool lastPassIsBounds; @@ -397,7 +397,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, passes[0] = NULL; } lastPassIsBounds = false; - drawFace[0] = GrDrawState::kBoth_DrawFace; + drawFace[0] = GrPipelineBuilder::kBoth_DrawFace; } else { if (single_pass_path(path, *stroke)) { passCount = 1; @@ -406,7 +406,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, } else { passes[0] = NULL; } - drawFace[0] = GrDrawState::kBoth_DrawFace; + drawFace[0] = GrPipelineBuilder::kBoth_DrawFace; lastPassIsBounds = false; } else { switch (path.getFillType()) { @@ -427,7 +427,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, passes[1] = &gEOColorPass; } } - drawFace[0] = drawFace[1] = GrDrawState::kBoth_DrawFace; + drawFace[0] = drawFace[1] = GrPipelineBuilder::kBoth_DrawFace; break; case SkPath::kInverseWinding_FillType: @@ -441,7 +441,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, passes[0] = &gWindStencilSeparateNoWrap; } passCount = 2; - drawFace[0] = GrDrawState::kBoth_DrawFace; + drawFace[0] = GrPipelineBuilder::kBoth_DrawFace; } else { if (fStencilWrapOps) { passes[0] = &gWindSingleStencilWithWrapInc; @@ -451,8 +451,8 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, passes[1] = &gWindSingleStencilNoWrapDec; } // which is cw and which is ccw is arbitrary. - drawFace[0] = GrDrawState::kCW_DrawFace; - drawFace[1] = GrDrawState::kCCW_DrawFace; + drawFace[0] = GrPipelineBuilder::kCW_DrawFace; + drawFace[1] = GrPipelineBuilder::kCCW_DrawFace; passCount = 3; } if (stencilOnly) { @@ -460,7 +460,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, --passCount; } else { lastPassIsBounds = true; - drawFace[passCount-1] = GrDrawState::kBoth_DrawFace; + drawFace[passCount-1] = GrPipelineBuilder::kBoth_DrawFace; if (reverse) { passes[passCount-1] = &gInvWindColorPass; } else { @@ -476,21 +476,21 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, } SkRect devBounds; - GetPathDevBounds(path, drawState->getRenderTarget(), viewMatrix, &devBounds); + GetPathDevBounds(path, pipelineBuilder->getRenderTarget(), viewMatrix, &devBounds); for (int p = 0; p < passCount; ++p) { - drawState->setDrawFace(drawFace[p]); + pipelineBuilder->setDrawFace(drawFace[p]); if (passes[p]) { - *drawState->stencil() = *passes[p]; + *pipelineBuilder->stencil() = *passes[p]; } if (lastPassIsBounds && (p == passCount-1)) { - // Reset the XP Factory on drawState - drawState->setXPFactory(backupXPFactory); + // Reset the XP Factory on pipelineBuilder + pipelineBuilder->setXPFactory(backupXPFactory); SkRect bounds; SkMatrix localMatrix = SkMatrix::I(); if (reverse) { - SkASSERT(drawState->getRenderTarget()); + SkASSERT(pipelineBuilder->getRenderTarget()); // draw over the dev bounds (which will be the whole dst surface for inv fill). bounds = devBounds; SkMatrix vmi; @@ -508,12 +508,12 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, GrDrawTarget::AutoGeometryPush agp(target); const SkMatrix& viewM = (reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() : viewMatrix; - target->drawRect(drawState, color, viewM, bounds, NULL, &localMatrix); + target->drawRect(pipelineBuilder, color, viewM, bounds, NULL, &localMatrix); } else { if (passCount > 1) { - drawState->setDisableColorXPFactory(); + pipelineBuilder->setDisableColorXPFactory(); } - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); SkAutoTUnref<const GrGeometryProcessor> gp( GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType, color, @@ -522,7 +522,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, false, newCoverage)); if (indexCnt) { - target->drawIndexed(drawState, + target->drawIndexed(pipelineBuilder, gp, primType, 0, @@ -531,7 +531,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, indexCnt, &devBounds); } else { - target->drawNonIndexed(drawState, gp, primType, 0, vertexCnt, &devBounds); + target->drawNonIndexed(pipelineBuilder, gp, primType, 0, vertexCnt, &devBounds); } } } @@ -539,7 +539,7 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target, } bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -551,14 +551,14 @@ bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget* target, } bool GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, bool antiAlias) { return this->internalDrawPath(target, - drawState, + pipelineBuilder, color, viewMatrix, path, @@ -567,11 +567,11 @@ bool GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target, } void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke) { SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType()); SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType()); - this->internalDrawPath(target, drawState, GrColor_WHITE, viewMatrix, path, stroke, true); + this->internalDrawPath(target, pipelineBuilder, GrColor_WHITE, viewMatrix, path, stroke, true); } diff --git a/src/gpu/GrDefaultPathRenderer.h b/src/gpu/GrDefaultPathRenderer.h index e1eea88414..5a805e5f7b 100644 --- a/src/gpu/GrDefaultPathRenderer.h +++ b/src/gpu/GrDefaultPathRenderer.h @@ -20,7 +20,7 @@ public: GrDefaultPathRenderer(bool separateStencilSupport, bool stencilWrapOpsSupport); virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -29,12 +29,12 @@ public: private: virtual StencilSupport onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const SK_OVERRIDE; virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -42,13 +42,13 @@ private: bool antiAlias) SK_OVERRIDE; virtual void onStencilPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&) SK_OVERRIDE; bool internalDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -56,7 +56,7 @@ private: bool stencilOnly); bool createGeom(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrPrimitiveType*, int* vertexCnt, int* indexCnt, diff --git a/src/gpu/GrDistanceFieldTextContext.cpp b/src/gpu/GrDistanceFieldTextContext.cpp index 14809756c8..425c56c892 100755 --- a/src/gpu/GrDistanceFieldTextContext.cpp +++ b/src/gpu/GrDistanceFieldTextContext.cpp @@ -636,8 +636,8 @@ void GrDistanceFieldTextContext::flush() { } if (fCurrVertex > 0) { - GrDrawState drawState; - drawState.setFromPaint(fPaint, fContext->getRenderTarget()); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setFromPaint(fPaint, fContext->getRenderTarget()); // setup our sampler state for our text texture/atlas SkASSERT(SkIsAlign4(fCurrVertex)); @@ -657,7 +657,8 @@ void GrDistanceFieldTextContext::flush() { // TODO: move supportsRGBCoverage check to setupCoverageEffect and only add LCD // processor if the xp can support it. For now we will simply assume that if // fUseLCDText is true, then we have a known color output. - if (!drawState.getXPFactory()->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) { + const GrXPFactory* xpFactory = pipelineBuilder.getXPFactory(); + if (!xpFactory->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) { SkDebugf("LCD Text will not draw correctly.\n"); } SkASSERT(!fCachedGeometryProcessor->hasVertexColor()); @@ -667,7 +668,7 @@ void GrDistanceFieldTextContext::flush() { } int nGlyphs = fCurrVertex / kVerticesPerGlyph; fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer()); - fDrawTarget->drawIndexedInstances(&drawState, + fDrawTarget->drawIndexedInstances(&pipelineBuilder, fCachedGeometryProcessor.get(), kTriangles_GrPrimitiveType, nGlyphs, diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp index f14515462a..e8a758d25f 100644 --- a/src/gpu/GrDrawTarget.cpp +++ b/src/gpu/GrDrawTarget.cpp @@ -306,7 +306,7 @@ void GrDrawTarget::popGeometrySource() { //////////////////////////////////////////////////////////////////////////////// -bool GrDrawTarget::checkDraw(const GrDrawState& drawState, +bool GrDrawTarget::checkDraw(const GrPipelineBuilder& pipelineBuilder, const GrGeometryProcessor* gp, GrPrimitiveType type, int startVertex, @@ -324,7 +324,8 @@ bool GrDrawTarget::checkDraw(const GrDrawState& drawState, maxValidVertex = geoSrc.fVertexCount; break; case kBuffer_GeometrySrcType: - maxValidVertex = static_cast<int>(geoSrc.fVertexBuffer->gpuMemorySize() / geoSrc.fVertexSize); + maxValidVertex = static_cast<int>(geoSrc.fVertexBuffer->gpuMemorySize() / + geoSrc.fVertexSize); break; } if (maxVertex > maxValidVertex) { @@ -340,7 +341,8 @@ bool GrDrawTarget::checkDraw(const GrDrawState& drawState, maxValidIndex = geoSrc.fIndexCount; break; case kBuffer_GeometrySrcType: - maxValidIndex = static_cast<int>(geoSrc.fIndexBuffer->gpuMemorySize() / sizeof(uint16_t)); + maxValidIndex = static_cast<int>(geoSrc.fIndexBuffer->gpuMemorySize() / + sizeof(uint16_t)); break; } if (maxIndex > maxValidIndex) { @@ -348,49 +350,49 @@ bool GrDrawTarget::checkDraw(const GrDrawState& drawState, } } - SkASSERT(drawState.getRenderTarget()); + SkASSERT(pipelineBuilder.getRenderTarget()); if (gp) { int numTextures = gp->numTextures(); for (int t = 0; t < numTextures; ++t) { GrTexture* texture = gp->texture(t); - SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget()); + SkASSERT(texture->asRenderTarget() != pipelineBuilder.getRenderTarget()); } } - for (int s = 0; s < drawState.numColorStages(); ++s) { - const GrProcessor* effect = drawState.getColorStage(s).processor(); + for (int s = 0; s < pipelineBuilder.numColorStages(); ++s) { + const GrProcessor* effect = pipelineBuilder.getColorStage(s).processor(); int numTextures = effect->numTextures(); for (int t = 0; t < numTextures; ++t) { GrTexture* texture = effect->texture(t); - SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget()); + SkASSERT(texture->asRenderTarget() != pipelineBuilder.getRenderTarget()); } } - for (int s = 0; s < drawState.numCoverageStages(); ++s) { - const GrProcessor* effect = drawState.getCoverageStage(s).processor(); + for (int s = 0; s < pipelineBuilder.numCoverageStages(); ++s) { + const GrProcessor* effect = pipelineBuilder.getCoverageStage(s).processor(); int numTextures = effect->numTextures(); for (int t = 0; t < numTextures; ++t) { GrTexture* texture = effect->texture(t); - SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget()); + SkASSERT(texture->asRenderTarget() != pipelineBuilder.getRenderTarget()); } } #endif - if (NULL == drawState.getRenderTarget()) { + if (NULL == pipelineBuilder.getRenderTarget()) { return false; } return true; } -bool GrDrawTarget::setupDstReadIfNecessary(GrDrawState* ds, +bool GrDrawTarget::setupDstReadIfNecessary(GrPipelineBuilder* pipelineBuilder, GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds) { - if (this->caps()->dstReadInShaderSupport() || !ds->willEffectReadDstColor()) { + if (this->caps()->dstReadInShaderSupport() || !pipelineBuilder->willEffectReadDstColor()) { return true; } SkIRect copyRect; const GrClipData* clip = this->getClip(); - GrRenderTarget* rt = ds->getRenderTarget(); + GrRenderTarget* rt = pipelineBuilder->getRenderTarget(); clip->getConservativeBounds(rt, ©Rect); if (drawBounds) { @@ -432,7 +434,7 @@ bool GrDrawTarget::setupDstReadIfNecessary(GrDrawState* ds, } } -void GrDrawTarget::drawIndexed(GrDrawState* ds, +void GrDrawTarget::drawIndexed(GrPipelineBuilder* pipelineBuilder, const GrGeometryProcessor* gp, GrPrimitiveType type, int startVertex, @@ -440,15 +442,16 @@ void GrDrawTarget::drawIndexed(GrDrawState* ds, int vertexCount, int indexCount, const SkRect* devBounds) { - SkASSERT(ds); + SkASSERT(pipelineBuilder); if (indexCount > 0 && - this->checkDraw(*ds, gp, type, startVertex, startIndex, vertexCount, indexCount)) { + this->checkDraw(*pipelineBuilder, gp, type, startVertex, startIndex, vertexCount, + indexCount)) { // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) { + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, devBounds)) { return; } @@ -469,29 +472,30 @@ void GrDrawTarget::drawIndexed(GrDrawState* ds, // TODO: We should continue with incorrect blending. GrDeviceCoordTexture dstCopy; - if (!this->setupDstReadIfNecessary(ds, &dstCopy, devBounds)) { + if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) { return; } this->setDrawBuffers(&info, gp->getVertexStride()); - this->onDraw(*ds, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL); + this->onDraw(*pipelineBuilder, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL); } } -void GrDrawTarget::drawNonIndexed(GrDrawState* ds, +void GrDrawTarget::drawNonIndexed(GrPipelineBuilder* pipelineBuilder, const GrGeometryProcessor* gp, GrPrimitiveType type, int startVertex, int vertexCount, const SkRect* devBounds) { - SkASSERT(ds); - if (vertexCount > 0 && this->checkDraw(*ds, gp, type, startVertex, -1, vertexCount, -1)) { + SkASSERT(pipelineBuilder); + if (vertexCount > 0 && this->checkDraw(*pipelineBuilder, gp, type, startVertex, -1, vertexCount, + -1)) { // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) { + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, devBounds)) { return; } @@ -512,13 +516,13 @@ void GrDrawTarget::drawNonIndexed(GrDrawState* ds, // TODO: We should continue with incorrect blending. GrDeviceCoordTexture dstCopy; - if (!this->setupDstReadIfNecessary(ds, &dstCopy, devBounds)) { + if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) { return; } this->setDrawBuffers(&info, gp->getVertexStride()); - this->onDraw(*ds, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL); + this->onDraw(*pipelineBuilder, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL); } } @@ -557,68 +561,68 @@ void GrDrawTarget::getPathStencilSettingsForFilltype(GrPathRendering::FillType f this->clipMaskManager()->adjustPathStencilParams(sb, outStencilSettings); } -void GrDrawTarget::stencilPath(GrDrawState* ds, +void GrDrawTarget::stencilPath(GrPipelineBuilder* pipelineBuilder, const GrPathProcessor* pathProc, const GrPath* path, GrPathRendering::FillType fill) { // TODO: extract portions of checkDraw that are relevant to path stenciling. SkASSERT(path); SkASSERT(this->caps()->pathRenderingSupport()); - SkASSERT(ds); + SkASSERT(pipelineBuilder); // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, NULL)) { + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, NULL)) { return; } // set stencil settings for path GrStencilSettings stencilSettings; this->getPathStencilSettingsForFilltype(fill, - ds->getRenderTarget()->getStencilBuffer(), + pipelineBuilder->getRenderTarget()->getStencilBuffer(), &stencilSettings); - this->onStencilPath(*ds, pathProc, path, scissorState, stencilSettings); + this->onStencilPath(*pipelineBuilder, pathProc, path, scissorState, stencilSettings); } -void GrDrawTarget::drawPath(GrDrawState* ds, +void GrDrawTarget::drawPath(GrPipelineBuilder* pipelineBuilder, const GrPathProcessor* pathProc, const GrPath* path, GrPathRendering::FillType fill) { // TODO: extract portions of checkDraw that are relevant to path rendering. SkASSERT(path); SkASSERT(this->caps()->pathRenderingSupport()); - SkASSERT(ds); + SkASSERT(pipelineBuilder); SkRect devBounds = path->getBounds(); pathProc->viewMatrix().mapRect(&devBounds); // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, &devBounds)) { + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, &devBounds)) { return; } // set stencil settings for path GrStencilSettings stencilSettings; this->getPathStencilSettingsForFilltype(fill, - ds->getRenderTarget()->getStencilBuffer(), + pipelineBuilder->getRenderTarget()->getStencilBuffer(), &stencilSettings); GrDeviceCoordTexture dstCopy; - if (!this->setupDstReadIfNecessary(ds, &dstCopy, &devBounds)) { + if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, &devBounds)) { return; } - this->onDrawPath(*ds, pathProc, path, scissorState, stencilSettings, dstCopy.texture() ? &dstCopy : - NULL); + this->onDrawPath(*pipelineBuilder, pathProc, path, scissorState, stencilSettings, + dstCopy.texture() ? &dstCopy : NULL); } -void GrDrawTarget::drawPaths(GrDrawState* ds, +void GrDrawTarget::drawPaths(GrPipelineBuilder* pipelineBuilder, const GrPathProcessor* pathProc, const GrPathRange* pathRange, const void* indices, @@ -632,21 +636,21 @@ void GrDrawTarget::drawPaths(GrDrawState* ds, SkASSERT(indices); SkASSERT(0 == reinterpret_cast<long>(indices) % GrPathRange::PathIndexSizeInBytes(indexType)); SkASSERT(transformValues); - SkASSERT(ds); + SkASSERT(pipelineBuilder); // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, NULL)) { + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, NULL)) { return; } // set stencil settings for path GrStencilSettings stencilSettings; this->getPathStencilSettingsForFilltype(fill, - ds->getRenderTarget()->getStencilBuffer(), + pipelineBuilder->getRenderTarget()->getStencilBuffer(), &stencilSettings); // Don't compute a bounding box for setupDstReadIfNecessary(), we'll opt @@ -654,12 +658,13 @@ void GrDrawTarget::drawPaths(GrDrawState* ds, // point, because any context that supports NV_path_rendering will also // support NV_blend_equation_advanced. GrDeviceCoordTexture dstCopy; - if (!this->setupDstReadIfNecessary(ds, &dstCopy, NULL)) { + if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, NULL)) { return; } - this->onDrawPaths(*ds, pathProc, pathRange, indices, indexType, transformValues, transformType, - count, scissorState, stencilSettings, dstCopy.texture() ? &dstCopy : NULL); + this->onDrawPaths(*pipelineBuilder, pathProc, pathRange, indices, indexType, transformValues, + transformType, count, scissorState, stencilSettings, + dstCopy.texture() ? &dstCopy : NULL); } void GrDrawTarget::clear(const SkIRect* rect, @@ -677,10 +682,10 @@ void GrDrawTarget::clear(const SkIRect* rect, this->discard(renderTarget); } - GrDrawState drawState; - drawState.setRenderTarget(renderTarget); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(renderTarget); - this->drawSimpleRect(&drawState, color, SkMatrix::I(), *rect); + this->drawSimpleRect(&pipelineBuilder, color, SkMatrix::I(), *rect); } else { this->onClear(rect, color, canIgnoreRect, renderTarget); } @@ -727,14 +732,14 @@ void GrDrawTarget::removeGpuTraceMarker(const GrGpuTraceMarker* marker) { //////////////////////////////////////////////////////////////////////////////// -void GrDrawTarget::drawIndexedInstances(GrDrawState* ds, +void GrDrawTarget::drawIndexedInstances(GrPipelineBuilder* pipelineBuilder, const GrGeometryProcessor* gp, GrPrimitiveType type, int instanceCount, int verticesPerInstance, int indicesPerInstance, const SkRect* devBounds) { - SkASSERT(ds); + SkASSERT(pipelineBuilder); if (!verticesPerInstance || !indicesPerInstance) { return; @@ -747,9 +752,9 @@ void GrDrawTarget::drawIndexedInstances(GrDrawState* ds, // Setup clip GrScissorState scissorState; - GrDrawState::AutoRestoreEffects are; - GrDrawState::AutoRestoreStencil ars; - if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) { + GrPipelineBuilder::AutoRestoreEffects are; + GrPipelineBuilder::AutoRestoreStencil ars; + if (!this->setupClip(pipelineBuilder, &are, &ars, &scissorState, devBounds)) { return; } @@ -767,7 +772,7 @@ void GrDrawTarget::drawIndexedInstances(GrDrawState* ds, // TODO: We should continue with incorrect blending. GrDeviceCoordTexture dstCopy; - if (!this->setupDstReadIfNecessary(ds, &dstCopy, devBounds)) { + if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) { return; } @@ -776,7 +781,7 @@ void GrDrawTarget::drawIndexedInstances(GrDrawState* ds, info.fVertexCount = info.fInstanceCount * verticesPerInstance; info.fIndexCount = info.fInstanceCount * indicesPerInstance; - if (this->checkDraw(*ds, + if (this->checkDraw(*pipelineBuilder, gp, type, info.fStartVertex, @@ -784,7 +789,8 @@ void GrDrawTarget::drawIndexedInstances(GrDrawState* ds, info.fVertexCount, info.fIndexCount)) { this->setDrawBuffers(&info, gp->getVertexStride()); - this->onDraw(*ds, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL); + this->onDraw(*pipelineBuilder, gp, info, scissorState, + dstCopy.texture() ? &dstCopy : NULL); } info.fStartVertex += info.fVertexCount; instanceCount -= info.fInstanceCount; @@ -938,18 +944,18 @@ bool GrDrawTarget::copySurface(GrSurface* dst, return false; } - GrDrawState drawState; - drawState.setRenderTarget(rt); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(rt); SkMatrix matrix; matrix.setTranslate(SkIntToScalar(clippedSrcRect.fLeft - clippedDstPoint.fX), SkIntToScalar(clippedSrcRect.fTop - clippedDstPoint.fY)); matrix.postIDiv(tex->width(), tex->height()); - drawState.addColorTextureProcessor(tex, matrix); + pipelineBuilder.addColorTextureProcessor(tex, matrix); SkIRect dstRect = SkIRect::MakeXYWH(clippedDstPoint.fX, clippedDstPoint.fY, clippedSrcRect.width(), clippedSrcRect.height()); - this->drawSimpleRect(&drawState, GrColor_WHITE, SkMatrix::I(), dstRect); + this->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, SkMatrix::I(), dstRect); return true; } @@ -1210,12 +1216,12 @@ uint32_t GrDrawTargetCaps::CreateUniqueID() { /////////////////////////////////////////////////////////////////////////////////////////////////// -bool GrClipTarget::setupClip(GrDrawState* ds, - GrDrawState::AutoRestoreEffects* are, - GrDrawState::AutoRestoreStencil* ars, +bool GrClipTarget::setupClip(GrPipelineBuilder* pipelineBuilder, + GrPipelineBuilder::AutoRestoreEffects* are, + GrPipelineBuilder::AutoRestoreStencil* ars, GrScissorState* scissorState, const SkRect* devBounds) { - return fClipMaskManager.setupClipping(ds, + return fClipMaskManager.setupClipping(pipelineBuilder, are, ars, scissorState, diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrDrawTarget.h index 6628e37228..b66f1c6bd3 100644 --- a/src/gpu/GrDrawTarget.h +++ b/src/gpu/GrDrawTarget.h @@ -11,9 +11,9 @@ #include "GrClipData.h" #include "GrClipMaskManager.h" #include "GrContext.h" -#include "GrDrawState.h" #include "GrIndexBuffer.h" #include "GrPathRendering.h" +#include "GrPipelineBuilder.h" #include "GrTraceMarker.h" #include "GrVertexBuffer.h" @@ -125,7 +125,7 @@ public: * snapshot of the data is made and the pointers are invalid. * * @param vertexCount the number of vertices to reserve space for. Can be - * 0. Vertex size is queried from the current GrDrawState. + * 0. Vertex size is queried from the current GrPipelineBuilder. * @param indexCount the number of indices to reserve space for. Can be 0. * @param vertices will point to reserved vertex space if vertexCount is * non-zero. Illegal to pass NULL if vertexCount > 0. @@ -148,7 +148,7 @@ public: * * @param vertexCount in: hint about how many vertices the caller would * like to allocate. Vertex size is queried from the - * current GrDrawState. + * current GrPipelineBuilder. * out: a hint about the number of vertices that can be * allocated cheaply. Negative means no hint. * Ignored if NULL. @@ -168,7 +168,7 @@ public: * * @param buffer vertex buffer containing vertex data. Must be * unlocked before draw call. Vertex size is queried - * from current GrDrawState. + * from current GrPipelineBuilder. */ void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride); @@ -232,7 +232,7 @@ public: * @param devBounds optional bounds hint. This is a promise from the caller, * not a request for clipping. */ - void drawIndexed(GrDrawState*, + void drawIndexed(GrPipelineBuilder*, const GrGeometryProcessor*, GrPrimitiveType type, int startVertex, @@ -252,7 +252,7 @@ public: * @param devBounds optional bounds hint. This is a promise from the caller, * not a request for clipping. */ - void drawNonIndexed(GrDrawState*, + void drawNonIndexed(GrPipelineBuilder*, const GrGeometryProcessor*, GrPrimitiveType type, int startVertex, @@ -262,21 +262,23 @@ public: /** * Draws path into the stencil buffer. The fill must be either even/odd or * winding (not inverse or hairline). It will respect the HW antialias flag - * on the draw state (if possible in the 3D API). Note, we will never have an inverse fill - * with stencil path + * on the GrPipelineBuilder (if possible in the 3D API). Note, we will never have an inverse + * fill with stencil path */ - void stencilPath(GrDrawState*, const GrPathProcessor*, const GrPath*,GrPathRendering::FillType); + void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*, + GrPathRendering::FillType); /** * Draws a path. Fill must not be a hairline. It will respect the HW - * antialias flag on the draw state (if possible in the 3D API). + * antialias flag on the GrPipelineBuilder (if possible in the 3D API). */ - void drawPath(GrDrawState*, const GrPathProcessor*, const GrPath*, GrPathRendering::FillType); + void drawPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*, + GrPathRendering::FillType); /** * Draws the aggregate path from combining multiple. Note that this will not * always be equivalent to back-to-back calls to drawPath(). It will respect - * the HW antialias flag on the draw state (if possible in the 3D API). + * the HW antialias flag on the GrPipelineBuilder (if possible in the 3D API). * * @param pathRange Source paths to draw from * @param indices Array of path indices to draw @@ -286,7 +288,7 @@ public: * @param count Number of paths to draw * @param fill Fill type for drawing all the paths */ - void drawPaths(GrDrawState*, + void drawPaths(GrPipelineBuilder*, const GrPathProcessor*, const GrPathRange* pathRange, const void* indices, @@ -308,7 +310,7 @@ public: * that rectangle before it is input to GrCoordTransforms that read local * coordinates */ - void drawRect(GrDrawState* ds, + void drawRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, @@ -321,10 +323,11 @@ public: /** * Helper for drawRect when the caller doesn't need separate local rects or matrices. */ - void drawSimpleRect(GrDrawState* ds, GrColor color, const SkMatrix& viewM, const SkRect& rect) { + void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM, + const SkRect& rect) { this->drawRect(ds, color, viewM, rect, NULL, NULL); } - void drawSimpleRect(GrDrawState* ds, GrColor color, const SkMatrix& viewM, + void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM, const SkIRect& irect) { SkRect rect = SkRect::Make(irect); this->drawRect(ds, color, viewM, rect, NULL, NULL); @@ -360,7 +363,7 @@ public: * @param devBounds optional bounds hint. This is a promise from the caller, * not a request for clipping. */ - void drawIndexedInstances(GrDrawState*, + void drawIndexedInstances(GrPipelineBuilder*, const GrGeometryProcessor*, GrPrimitiveType type, int instanceCount, @@ -369,9 +372,9 @@ public: const SkRect* devBounds = NULL); /** - * Clear the passed in render target. Ignores the draw state and clip. Clears the whole thing if - * rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire render target - * can be optionally cleared. + * Clear the passed in render target. Ignores the GrPipelineBuilder and clip. Clears the whole + * thing if rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire + * render target can be optionally cleared. */ void clear(const SkIRect* rect, GrColor color, @@ -660,7 +663,7 @@ protected: // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required // but couldn't be made. Otherwise, returns true. This method needs to be protected because it // needs to be accessed by GLPrograms to setup a correct drawstate - bool setupDstReadIfNecessary(GrDrawState*, + bool setupDstReadIfNecessary(GrPipelineBuilder*, GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds); @@ -700,31 +703,31 @@ private: virtual void geometrySourceWillPush() = 0; virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0; // subclass called to perform drawing - virtual void onDraw(const GrDrawState&, + virtual void onDraw(const GrPipelineBuilder&, const GrGeometryProcessor*, const DrawInfo&, const GrScissorState&, const GrDeviceCoordTexture* dstCopy) = 0; // TODO copy in order drawbuffer onDrawRect to here - virtual void onDrawRect(GrDrawState*, + virtual void onDrawRect(GrPipelineBuilder*, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect* localRect, const SkMatrix* localMatrix) = 0; - virtual void onStencilPath(const GrDrawState&, + virtual void onStencilPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*, const GrScissorState&, const GrStencilSettings&) = 0; - virtual void onDrawPath(const GrDrawState&, + virtual void onDrawPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*, const GrScissorState&, const GrStencilSettings&, const GrDeviceCoordTexture* dstCopy) = 0; - virtual void onDrawPaths(const GrDrawState&, + virtual void onDrawPaths(const GrPipelineBuilder&, const GrPathProcessor*, const GrPathRange*, const void* indices, @@ -771,7 +774,7 @@ private: // called by drawIndexed and drawNonIndexed. Use a negative indexCount to // indicate non-indexed drawing. - bool checkDraw(const GrDrawState&, + bool checkDraw(const GrPipelineBuilder&, const GrGeometryProcessor*, GrPrimitiveType type, int startVertex, @@ -788,9 +791,9 @@ private: const GrStencilBuffer*, GrStencilSettings*); virtual GrClipMaskManager* clipMaskManager() = 0; - virtual bool setupClip(GrDrawState*, - GrDrawState::AutoRestoreEffects* are, - GrDrawState::AutoRestoreStencil* ars, + virtual bool setupClip(GrPipelineBuilder*, + GrPipelineBuilder::AutoRestoreEffects* are, + GrPipelineBuilder::AutoRestoreStencil* ars, GrScissorState* scissorState, const SkRect* devBounds) = 0; @@ -848,9 +851,9 @@ protected: private: GrClipMaskManager* clipMaskManager() SK_OVERRIDE { return &fClipMaskManager; } - virtual bool setupClip(GrDrawState*, - GrDrawState::AutoRestoreEffects* are, - GrDrawState::AutoRestoreStencil* ars, + virtual bool setupClip(GrPipelineBuilder*, + GrPipelineBuilder::AutoRestoreEffects* are, + GrPipelineBuilder::AutoRestoreStencil* ars, GrScissorState* scissorState, const SkRect* devBounds) SK_OVERRIDE; diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h index 5bbc3dcb05..17bed8b9b1 100644 --- a/src/gpu/GrGpu.h +++ b/src/gpu/GrGpu.h @@ -15,11 +15,11 @@ class GrContext; class GrIndexBufferAllocPool; -class GrOptDrawState; class GrPath; class GrPathRange; class GrPathRenderer; class GrPathRendererChain; +class GrPipeline; class GrPrimitiveProcessor; class GrStencilBuffer; class GrVertexBufferAllocPool; @@ -306,7 +306,7 @@ public: virtual void buildProgramDesc(GrProgramDesc*, const GrPrimitiveProcessor&, - const GrOptDrawState&, + const GrPipeline&, const GrProgramDesc::DescInfo&, const GrBatchTracker&) const = 0; @@ -351,17 +351,17 @@ public: struct DrawArgs { typedef GrDrawTarget::DrawInfo DrawInfo; DrawArgs(const GrPrimitiveProcessor* primProc, - const GrOptDrawState* optState, + const GrPipeline* pipeline, const GrProgramDesc* desc, const GrBatchTracker* batchTracker) : fPrimitiveProcessor(primProc) - , fOptState(optState) + , fPipeline(pipeline) , fDesc(desc) , fBatchTracker(batchTracker) { - SkASSERT(primProc && optState && desc && batchTracker); + SkASSERT(primProc && pipeline && desc && batchTracker); } const GrPrimitiveProcessor* fPrimitiveProcessor; - const GrOptDrawState* fOptState; + const GrPipeline* fPipeline; const GrProgramDesc* fDesc; const GrBatchTracker* fBatchTracker; }; diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp index 5b1f00891e..70d61ecfff 100644 --- a/src/gpu/GrInOrderDrawBuffer.cpp +++ b/src/gpu/GrInOrderDrawBuffer.cpp @@ -114,13 +114,13 @@ static inline uint8_t strip_trace_bit(uint8_t cmd) { return cmd & kCmdMask; } static inline bool cmd_has_trace_marker(uint8_t cmd) { return SkToBool(cmd & kTraceCmdBit); } -void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds, +void GrInOrderDrawBuffer::onDrawRect(GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect* localRect, const SkMatrix* localMatrix) { - GrDrawState::AutoRestoreEffects are(ds); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); // Go to device coords to allow batching across matrix changes SkMatrix invert = SkMatrix::I(); @@ -183,10 +183,12 @@ void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds, } this->setIndexSourceToBuffer(this->getContext()->getQuadIndexBuffer()); - this->drawIndexedInstances(ds, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &devBounds); + this->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, 4, 6, + &devBounds); } -int GrInOrderDrawBuffer::concatInstancedDraw(const GrDrawState& ds, const DrawInfo& info) { +int GrInOrderDrawBuffer::concatInstancedDraw(const GrPipelineBuilder& pipelineBuilder, + const DrawInfo& info) { SkASSERT(!fCmdBuffer.empty()); SkASSERT(info.isInstanced()); @@ -238,20 +240,20 @@ int GrInOrderDrawBuffer::concatInstancedDraw(const GrDrawState& ds, const DrawIn return instancesToConcat; } -void GrInOrderDrawBuffer::onDraw(const GrDrawState& ds, +void GrInOrderDrawBuffer::onDraw(const GrPipelineBuilder& pipelineBuilder, const GrGeometryProcessor* gp, const DrawInfo& info, const GrScissorState& scissorState, const GrDeviceCoordTexture* dstCopy) { SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer())); - if (!this->recordStateAndShouldDraw(ds, gp, scissorState, dstCopy)) { + if (!this->recordStateAndShouldDraw(pipelineBuilder, gp, scissorState, dstCopy)) { return; } Draw* draw; if (info.isInstanced()) { - int instancesConcated = this->concatInstancedDraw(ds, info); + int instancesConcated = this->concatInstancedDraw(pipelineBuilder, info); if (info.instanceCount() > instancesConcated) { draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info)); draw->fInfo.adjustInstanceCount(-instancesConcated); @@ -264,28 +266,28 @@ void GrInOrderDrawBuffer::onDraw(const GrDrawState& ds, this->recordTraceMarkersIfNecessary(); } -void GrInOrderDrawBuffer::onStencilPath(const GrDrawState& ds, +void GrInOrderDrawBuffer::onStencilPath(const GrPipelineBuilder& pipelineBuilder, const GrPathProcessor* pathProc, const GrPath* path, const GrScissorState& scissorState, const GrStencilSettings& stencilSettings) { StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath, - (path, ds.getRenderTarget())); + (path, pipelineBuilder.getRenderTarget())); sp->fScissor = scissorState; - sp->fUseHWAA = ds.isHWAntialias(); + sp->fUseHWAA = pipelineBuilder.isHWAntialias(); sp->fViewMatrix = pathProc->viewMatrix(); sp->fStencil = stencilSettings; this->recordTraceMarkersIfNecessary(); } -void GrInOrderDrawBuffer::onDrawPath(const GrDrawState& ds, +void GrInOrderDrawBuffer::onDrawPath(const GrPipelineBuilder& pipelineBuilder, const GrPathProcessor* pathProc, const GrPath* path, const GrScissorState& scissorState, const GrStencilSettings& stencilSettings, const GrDeviceCoordTexture* dstCopy) { - // TODO: Only compare the subset of GrDrawState relevant to path covering? - if (!this->recordStateAndShouldDraw(ds, pathProc, scissorState, dstCopy)) { + // TODO: Only compare the subset of GrPipelineBuilder relevant to path covering? + if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, dstCopy)) { return; } DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path)); @@ -293,7 +295,7 @@ void GrInOrderDrawBuffer::onDrawPath(const GrDrawState& ds, this->recordTraceMarkersIfNecessary(); } -void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds, +void GrInOrderDrawBuffer::onDrawPaths(const GrPipelineBuilder& pipelineBuilder, const GrPathProcessor* pathProc, const GrPathRange* pathRange, const void* indices, @@ -308,7 +310,7 @@ void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds, SkASSERT(indices); SkASSERT(transformValues); - if (!this->recordStateAndShouldDraw(ds, pathProc, scissorState, dstCopy)) { + if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, dstCopy)) { return; } @@ -338,7 +340,7 @@ void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds, transformType == previous->fTransformType && stencilSettings == previous->fStencilSettings && path_fill_type_is_winding(stencilSettings) && - !ds.willBlendWithDst(pathProc)) { + !pipelineBuilder.willBlendWithDst(pathProc)) { // Fold this DrawPaths call into the one previous. previous->fCount += count; return; @@ -430,8 +432,8 @@ void GrInOrderDrawBuffer::onFlush() { if (kSetState_Cmd == strip_trace_bit(iter->fType)) { SetState* ss = reinterpret_cast<SetState*>(iter.get()); - this->getGpu()->buildProgramDesc(&ss->fDesc, *ss->fPrimitiveProcessor, ss->fState, - ss->fState.descInfo(), ss->fBatchTracker); + this->getGpu()->buildProgramDesc(&ss->fDesc, *ss->fPrimitiveProcessor, ss->fPipeline, + ss->fPipeline.descInfo(), ss->fBatchTracker); currentState = ss; } else { @@ -449,7 +451,7 @@ void GrInOrderDrawBuffer::onFlush() { void GrInOrderDrawBuffer::Draw::execute(GrInOrderDrawBuffer* buf, const SetState* state) { SkASSERT(state); - DrawArgs args(state->fPrimitiveProcessor.get(), &state->fState, &state->fDesc, + DrawArgs args(state->fPrimitiveProcessor.get(), &state->fPipeline, &state->fDesc, &state->fBatchTracker); buf->getGpu()->draw(args, fInfo); } @@ -467,14 +469,14 @@ void GrInOrderDrawBuffer::StencilPath::execute(GrInOrderDrawBuffer* buf, const S void GrInOrderDrawBuffer::DrawPath::execute(GrInOrderDrawBuffer* buf, const SetState* state) { SkASSERT(state); - DrawArgs args(state->fPrimitiveProcessor.get(), &state->fState, &state->fDesc, + DrawArgs args(state->fPrimitiveProcessor.get(), &state->fPipeline, &state->fDesc, &state->fBatchTracker); buf->getGpu()->drawPath(args, this->path(), fStencilSettings); } void GrInOrderDrawBuffer::DrawPaths::execute(GrInOrderDrawBuffer* buf, const SetState* state) { SkASSERT(state); - DrawArgs args(state->fPrimitiveProcessor.get(), &state->fState, &state->fDesc, + DrawArgs args(state->fPrimitiveProcessor.get(), &state->fPipeline, &state->fDesc, &state->fBatchTracker); buf->getGpu()->drawPaths(args, this->pathRange(), &buf->fPathIndexBuffer[fIndicesLocation], fIndexType, @@ -514,26 +516,26 @@ bool GrInOrderDrawBuffer::onCopySurface(GrSurface* dst, return false; } -bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds, +bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrPipelineBuilder& pipelineBuilder, const GrPrimitiveProcessor* primProc, const GrScissorState& scissor, const GrDeviceCoordTexture* dstCopy) { SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, - (ds, primProc, *this->getGpu()->caps(), scissor, - dstCopy)); - if (ss->fState.mustSkip()) { + (pipelineBuilder, primProc, *this->getGpu()->caps(), + scissor, dstCopy)); + if (ss->fPipeline.mustSkip()) { fCmdBuffer.pop_back(); return false; } ss->fPrimitiveProcessor->initBatchTracker(&ss->fBatchTracker, - ss->fState.getInitBatchTracker()); + ss->fPipeline.getInitBatchTracker()); if (fPrevState && fPrevState->fPrimitiveProcessor->canMakeEqual(fPrevState->fBatchTracker, *ss->fPrimitiveProcessor, ss->fBatchTracker) && - fPrevState->fState.isEqual(ss->fState)) { + fPrevState->fPipeline.isEqual(ss->fPipeline)) { fCmdBuffer.pop_back(); } else { fPrevState = ss; diff --git a/src/gpu/GrInOrderDrawBuffer.h b/src/gpu/GrInOrderDrawBuffer.h index ea1279bc57..afa7d27394 100644 --- a/src/gpu/GrInOrderDrawBuffer.h +++ b/src/gpu/GrInOrderDrawBuffer.h @@ -9,7 +9,7 @@ #define GrInOrderDrawBuffer_DEFINED #include "GrFlushToGpuDrawTarget.h" -#include "GrOptDrawState.h" +#include "GrPipeline.h" #include "GrPath.h" #include "GrTRecorder.h" @@ -178,19 +178,20 @@ private: GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc; }; + // TODO: rename to SetPipeline once pp, batch tracker, and desc are removed struct SetState : public Cmd { - SetState(const GrDrawState& drawState, const GrPrimitiveProcessor* primProc, + SetState(const GrPipelineBuilder& pipelineBuilder, const GrPrimitiveProcessor* primProc, const GrDrawTargetCaps& caps, const GrScissorState& scissor, const GrDeviceCoordTexture* dstCopy) : Cmd(kSetState_Cmd) , fPrimitiveProcessor(primProc) - , fState(drawState, primProc, caps, scissor, dstCopy) {} + , fPipeline(pipelineBuilder, primProc, caps, scissor, dstCopy) {} void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE; typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor; ProgramPrimitiveProcessor fPrimitiveProcessor; - const GrOptDrawState fState; + const GrPipeline fPipeline; GrProgramDesc fDesc; GrBatchTracker fBatchTracker; }; @@ -202,30 +203,30 @@ private: void onFlush() SK_OVERRIDE; // overrides from GrDrawTarget - void onDraw(const GrDrawState&, + void onDraw(const GrPipelineBuilder&, const GrGeometryProcessor*, const DrawInfo&, const GrScissorState&, const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE; - void onDrawRect(GrDrawState*, + void onDrawRect(GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkRect& rect, const SkRect* localRect, const SkMatrix* localMatrix) SK_OVERRIDE; - void onStencilPath(const GrDrawState&, + void onStencilPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*, const GrScissorState&, const GrStencilSettings&) SK_OVERRIDE; - void onDrawPath(const GrDrawState&, + void onDrawPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*, const GrScissorState&, const GrStencilSettings&, const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE; - void onDrawPaths(const GrDrawState&, + void onDrawPaths(const GrPipelineBuilder&, const GrPathProcessor*, const GrPathRange*, const void* indices, @@ -247,12 +248,12 @@ private: // Attempts to concat instances from info onto the previous draw. info must represent an // instanced draw. The caller must have already recorded a new draw state and clip if necessary. - int concatInstancedDraw(const GrDrawState&, const DrawInfo&); + int concatInstancedDraw(const GrPipelineBuilder&, const DrawInfo&); - // Determines whether the current draw operation requires a new GrOptDrawState and if so - // records it. If the draw can be skipped false is returned and no new GrOptDrawState is + // Determines whether the current draw operation requires a new GrPipeline and if so + // records it. If the draw can be skipped false is returned and no new GrPipeline is // recorded. - bool SK_WARN_UNUSED_RESULT recordStateAndShouldDraw(const GrDrawState&, + bool SK_WARN_UNUSED_RESULT recordStateAndShouldDraw(const GrPipelineBuilder&, const GrPrimitiveProcessor*, const GrScissorState&, const GrDeviceCoordTexture*); diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp index a35d70859a..4b24e4542b 100644 --- a/src/gpu/GrOvalRenderer.cpp +++ b/src/gpu/GrOvalRenderer.cpp @@ -8,11 +8,11 @@ #include "GrOvalRenderer.h" #include "GrProcessor.h" -#include "GrDrawState.h" #include "GrDrawTarget.h" #include "GrGeometryProcessor.h" #include "GrGpu.h" #include "GrInvariantOutput.h" +#include "GrPipelineBuilder.h" #include "SkRRect.h" #include "SkStrokeRec.h" #include "SkTLazy.h" @@ -657,7 +657,7 @@ void GrOvalRenderer::reset() { } bool GrOvalRenderer::drawOval(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useAA, @@ -665,8 +665,8 @@ bool GrOvalRenderer::drawOval(GrDrawTarget* target, const SkStrokeRec& stroke) { bool useCoverageAA = useAA && - !drawState->getRenderTarget()->isMultisampled() && - drawState->canUseFracCoveragePrimProc(color, *target->caps()); + !pipelineBuilder->getRenderTarget()->isMultisampled() && + pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps()); if (!useCoverageAA) { return false; @@ -674,14 +674,15 @@ bool GrOvalRenderer::drawOval(GrDrawTarget* target, // we can draw circles if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) { - this->drawCircle(target, drawState, color, viewMatrix, useCoverageAA, oval, stroke); + this->drawCircle(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval, stroke); // if we have shader derivative support, render as device-independent } else if (target->caps()->shaderDerivativeSupport()) { - return this->drawDIEllipse(target, drawState, color, viewMatrix, useCoverageAA, oval, + return this->drawDIEllipse(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval, stroke); // otherwise axis-aligned ellipses only } else if (viewMatrix.rectStaysRect()) { - return this->drawEllipse(target, drawState, color, viewMatrix, useCoverageAA, oval, stroke); + return this->drawEllipse(target, pipelineBuilder, color, viewMatrix, useCoverageAA, oval, + stroke); } else { return false; } @@ -692,7 +693,7 @@ bool GrOvalRenderer::drawOval(GrDrawTarget* target, /////////////////////////////////////////////////////////////////////////////// void GrOvalRenderer::drawCircle(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useCoverageAA, @@ -778,14 +779,14 @@ void GrOvalRenderer::drawCircle(GrDrawTarget* target, verts[3].fInnerRadius = innerRadius; target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer()); - target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); target->resetIndexSource(); } /////////////////////////////////////////////////////////////////////////////// bool GrOvalRenderer::drawEllipse(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useCoverageAA, @@ -912,14 +913,14 @@ bool GrOvalRenderer::drawEllipse(GrDrawTarget* target, verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer()); - target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); target->resetIndexSource(); return true; } bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useCoverageAA, @@ -1020,7 +1021,7 @@ bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target, verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy); target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer()); - target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds); target->resetIndexSource(); return true; @@ -1072,16 +1073,16 @@ GrIndexBuffer* GrOvalRenderer::rRectIndexBuffer(bool isStrokeOnly) { } bool GrOvalRenderer::drawDRRect(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useAA, const SkRRect& origOuter, const SkRRect& origInner) { bool applyAA = useAA && - !drawState->getRenderTarget()->isMultisampled() && - drawState->canUseFracCoveragePrimProc(color, *target->caps()); - GrDrawState::AutoRestoreEffects are; + !pipelineBuilder->getRenderTarget()->isMultisampled() && + pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps()); + GrPipelineBuilder::AutoRestoreEffects are; if (!origInner.isEmpty()) { SkTCopyOnFirstWrite<SkRRect> inner(origInner); if (!viewMatrix.isIdentity()) { @@ -1097,12 +1098,12 @@ bool GrOvalRenderer::drawDRRect(GrDrawTarget* target, if (NULL == fp) { return false; } - are.set(drawState); - drawState->addCoverageProcessor(fp)->unref(); + are.set(pipelineBuilder); + pipelineBuilder->addCoverageProcessor(fp)->unref(); } SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle); - if (this->drawRRect(target, drawState, color, viewMatrix, useAA, origOuter, fillRec)) { + if (this->drawRRect(target, pipelineBuilder, color, viewMatrix, useAA, origOuter, fillRec)) { return true; } @@ -1120,7 +1121,7 @@ bool GrOvalRenderer::drawDRRect(GrDrawTarget* target, return false; } if (!are.isSet()) { - are.set(drawState); + are.set(pipelineBuilder); } SkMatrix invert; @@ -1128,30 +1129,30 @@ bool GrOvalRenderer::drawDRRect(GrDrawTarget* target, return false; } - drawState->addCoverageProcessor(effect)->unref(); + pipelineBuilder->addCoverageProcessor(effect)->unref(); SkRect bounds = outer->getBounds(); if (applyAA) { bounds.outset(SK_ScalarHalf, SK_ScalarHalf); } - target->drawRect(drawState, color, SkMatrix::I(), bounds, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), bounds, NULL, &invert); return true; } bool GrOvalRenderer::drawRRect(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, bool useAA, const SkRRect& rrect, const SkStrokeRec& stroke) { if (rrect.isOval()) { - return this->drawOval(target, drawState, color, viewMatrix, useAA, rrect.getBounds(), + return this->drawOval(target, pipelineBuilder, color, viewMatrix, useAA, rrect.getBounds(), stroke); } bool useCoverageAA = useAA && - !drawState->getRenderTarget()->isMultisampled() && - drawState->canUseFracCoveragePrimProc(color, *target->caps()); + !pipelineBuilder->getRenderTarget()->isMultisampled() && + pipelineBuilder->canUseFracCoveragePrimProc(color, *target->caps()); // only anti-aliased rrects for now if (!useCoverageAA) { @@ -1304,8 +1305,8 @@ bool GrOvalRenderer::drawRRect(GrDrawTarget* target, int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : SK_ARRAY_COUNT(gRRectIndices); target->setIndexSourceToBuffer(indexBuffer); - target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt, - &bounds); + target->drawIndexedInstances(pipelineBuilder, effect, kTriangles_GrPrimitiveType, 1, 16, + indexCnt, &bounds); // otherwise we use the ellipse renderer } else { @@ -1412,8 +1413,8 @@ bool GrOvalRenderer::drawRRect(GrDrawTarget* target, int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : SK_ARRAY_COUNT(gRRectIndices); target->setIndexSourceToBuffer(indexBuffer); - target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt, - &bounds); + target->drawIndexedInstances(pipelineBuilder, effect, kTriangles_GrPrimitiveType, 1, 16, + indexCnt, &bounds); } target->resetIndexSource(); diff --git a/src/gpu/GrOvalRenderer.h b/src/gpu/GrOvalRenderer.h index 16c1248b3f..9d861c5b8d 100644 --- a/src/gpu/GrOvalRenderer.h +++ b/src/gpu/GrOvalRenderer.h @@ -35,21 +35,21 @@ public: void reset(); bool drawOval(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useAA, const SkRect& oval, const SkStrokeRec& stroke); bool drawRRect(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useAA, const SkRRect& rrect, const SkStrokeRec& stroke); bool drawDRRect(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useAA, @@ -58,21 +58,21 @@ public: private: bool drawEllipse(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useCoverageAA, const SkRect& ellipse, const SkStrokeRec& stroke); bool drawDIEllipse(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useCoverageAA, const SkRect& ellipse, const SkStrokeRec& stroke); void drawCircle(GrDrawTarget* target, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, bool useCoverageAA, diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h index 6f087b4434..5144597ab5 100644 --- a/src/gpu/GrPathRenderer.h +++ b/src/gpu/GrPathRenderer.h @@ -24,8 +24,8 @@ struct GrPoint; /** * Base class for drawing paths into a GrDrawTarget. * - * Derived classes can use stages GrPaint::kTotalStages through GrDrawState::kNumStages-1. The - * stages before GrPaint::kTotalStages are reserved for setting up the draw (i.e., textures and + * Derived classes can use stages GrPaint::kTotalStages through GrPipelineBuilder::kNumStages-1. + * The stages before GrPaint::kTotalStages are reserved for setting up the draw (i.e., textures and * filter masks). */ class SK_API GrPathRenderer : public SkRefCnt { @@ -54,7 +54,7 @@ public: * rendered into the stencil. * * A GrPathRenderer can provide three levels of support for stenciling paths: - * 1) kNoRestriction: This is the most general. The caller sets up the GrDrawState on the target + * 1) kNoRestriction: This is the most general. The caller sets up the GrPipelineBuilder on the target * and calls drawPath(). The path is rendered exactly as the draw state * indicates including support for simultaneous color and stenciling with * arbitrary stenciling rules. Pixels partially covered by AA paths are @@ -82,11 +82,11 @@ public: * @param stroke the stroke information (width, join, cap). */ StencilSupport getStencilSupport(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkPath& path, const SkStrokeRec& stroke) const { SkASSERT(!path.isInverseFillType()); - return this->onGetStencilSupport(target, drawState, path, stroke); + return this->onGetStencilSupport(target, pipelineBuilder, path, stroke); } /** @@ -94,17 +94,17 @@ public: * caller to fallback to another path renderer This function is called when searching for a path * renderer capable of rendering a path. * - * @param target The target that the path will be rendered to - * @param drawState The drawState - * @param viewMatrix The viewMatrix - * @param path The path to draw - * @param stroke The stroke information (width, join, cap) - * @param antiAlias True if anti-aliasing is required. + * @param target The target that the path will be rendered to + * @param pipelineBuilder The pipelineBuilder + * @param viewMatrix The viewMatrix + * @param path The path to draw + * @param stroke The stroke information (width, join, cap) + * @param antiAlias True if anti-aliasing is required. * * @return true if the path can be drawn by this object, false otherwise. */ virtual bool canDrawPath(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& rec, @@ -114,14 +114,14 @@ public: * the subclass must respect the stencil settings of the target's draw state. * * @param target The target that the path will be rendered to - * @param drawState The drawState + * @param pipelineBuilder The pipelineBuilder * @param viewMatrix The viewMatrix * @param path the path to draw. * @param stroke the stroke information (width, join, cap) * @param antiAlias true if anti-aliasing is required. */ bool drawPath(GrDrawTarget* target, - GrDrawState* ds, + GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -144,7 +144,7 @@ public: * @param target target that the path will be rendered to */ void stencilPath(GrDrawTarget* target, - GrDrawState* ds, + GrPipelineBuilder* ds, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke) { @@ -172,7 +172,7 @@ protected: * Subclass overrides if it has any limitations of stenciling support. */ virtual StencilSupport onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const { return kNoRestriction_StencilSupport; @@ -182,7 +182,7 @@ protected: * Subclass implementation of drawPath() */ virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -194,7 +194,7 @@ protected: * kStencilOnly in onGetStencilSupport(). */ virtual void onStencilPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke) { @@ -205,9 +205,9 @@ protected: 0xffff, 0xffff, 0xffff); - drawState->setStencil(kIncrementStencil); - drawState->setDisableColorXPFactory(); - this->drawPath(target, drawState, GrColor_WHITE, viewMatrix, path, stroke, false); + pipelineBuilder->setStencil(kIncrementStencil); + pipelineBuilder->setDisableColorXPFactory(); + this->drawPath(target, pipelineBuilder, GrColor_WHITE, viewMatrix, path, stroke, false); } // Helper for getting the device bounds of a path. Inverse filled paths will have bounds set diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp index 0ba9364cd4..d11763bff1 100644 --- a/src/gpu/GrPathRendererChain.cpp +++ b/src/gpu/GrPathRendererChain.cpp @@ -32,7 +32,7 @@ GrPathRenderer* GrPathRendererChain::addPathRenderer(GrPathRenderer* pr) { } GrPathRenderer* GrPathRendererChain::getPathRenderer(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, @@ -60,12 +60,10 @@ GrPathRenderer* GrPathRendererChain::getPathRenderer(const GrDrawTarget* target, for (int i = 0; i < fChain.count(); ++i) { - if (fChain[i]->canDrawPath(target, drawState, viewMatrix, path, stroke, antiAlias)) { + if (fChain[i]->canDrawPath(target, pipelineBuilder, viewMatrix, path, stroke, antiAlias)) { if (GrPathRenderer::kNoSupport_StencilSupport != minStencilSupport) { - GrPathRenderer::StencilSupport support = fChain[i]->getStencilSupport(target, - drawState, - path, - stroke); + GrPathRenderer::StencilSupport support = + fChain[i]->getStencilSupport(target, pipelineBuilder, path, stroke); if (support < minStencilSupport) { continue; } else if (stencilSupport) { diff --git a/src/gpu/GrOptDrawState.cpp b/src/gpu/GrPipeline.cpp index a111007114..c35808e033 100644 --- a/src/gpu/GrOptDrawState.cpp +++ b/src/gpu/GrPipeline.cpp @@ -1,29 +1,29 @@ /* - * Copyright 2014 Google Inc. + * Copyright 2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ -#include "GrOptDrawState.h" +#include "GrPipeline.h" -#include "GrDrawState.h" #include "GrDrawTargetCaps.h" #include "GrGpu.h" +#include "GrPipelineBuilder.h" #include "GrProcOptInfo.h" #include "GrXferProcessor.h" -GrOptDrawState::GrOptDrawState(const GrDrawState& drawState, +GrPipeline::GrPipeline(const GrPipelineBuilder& pipelineBuilder, const GrPrimitiveProcessor* primProc, const GrDrawTargetCaps& caps, const GrScissorState& scissorState, const GrDeviceCoordTexture* dstCopy) { - const GrProcOptInfo& colorPOI = drawState.colorProcInfo(primProc); - const GrProcOptInfo& coveragePOI = drawState.coverageProcInfo(primProc); + const GrProcOptInfo& colorPOI = pipelineBuilder.colorProcInfo(primProc); + const GrProcOptInfo& coveragePOI = pipelineBuilder.coverageProcInfo(primProc); // Create XferProcessor from DS's XPFactory SkAutoTUnref<GrXferProcessor> xferProcessor( - drawState.getXPFactory()->createXferProcessor(colorPOI, coveragePOI)); + pipelineBuilder.getXPFactory()->createXferProcessor(colorPOI, coveragePOI)); GrColor overrideColor = GrColor_ILLEGAL; if (colorPOI.firstEffectiveStageIndex() != 0) { @@ -36,72 +36,72 @@ GrOptDrawState::GrOptDrawState(const GrDrawState& drawState, optFlags = xferProcessor->getOptimizations(colorPOI, coveragePOI, - drawState.getStencil().doesWrite(), + pipelineBuilder.getStencil().doesWrite(), &overrideColor, caps); } - // When path rendering the stencil settings are not always set on the draw state + // When path rendering the stencil settings are not always set on the GrPipelineBuilder // so we must check the draw type. In cases where we will skip drawing we simply return a - // null GrOptDrawState. + // null GrPipeline. if (!xferProcessor || (GrXferProcessor::kSkipDraw_OptFlag & optFlags)) { // Set the fields that don't default init and return. The lack of a render target will // indicate that this can be skipped. fFlags = 0; - fDrawFace = GrDrawState::kInvalid_DrawFace; + fDrawFace = GrPipelineBuilder::kInvalid_DrawFace; return; } - fRenderTarget.reset(drawState.fRenderTarget.get()); + fRenderTarget.reset(pipelineBuilder.fRenderTarget.get()); SkASSERT(fRenderTarget); fScissorState = scissorState; - fStencilSettings = drawState.getStencil(); - fDrawFace = drawState.getDrawFace(); - // TODO move this out of optDrawState + fStencilSettings = pipelineBuilder.getStencil(); + fDrawFace = pipelineBuilder.getDrawFace(); + // TODO move this out of GrPipeline if (dstCopy) { fDstCopy = *dstCopy; } fFlags = 0; - if (drawState.isHWAntialias()) { + if (pipelineBuilder.isHWAntialias()) { fFlags |= kHWAA_Flag; } - if (drawState.isDither()) { + if (pipelineBuilder.isDither()) { fFlags |= kDither_Flag; } int firstColorStageIdx = colorPOI.firstEffectiveStageIndex(); // TODO: Once we can handle single or four channel input into coverage stages then we can use - // drawState's coverageProcInfo (like color above) to set this initial information. + // GrPipelineBuilder's coverageProcInfo (like color above) to set this initial information. int firstCoverageStageIdx = 0; GrXferProcessor::BlendInfo blendInfo; fXferProcessor->getBlendInfo(&blendInfo); - this->adjustProgramFromOptimizations(drawState, optFlags, colorPOI, coveragePOI, + this->adjustProgramFromOptimizations(pipelineBuilder, optFlags, colorPOI, coveragePOI, &firstColorStageIdx, &firstCoverageStageIdx); fDescInfo.fReadsDst = fXferProcessor->willReadDstColor(); bool usesLocalCoords = false; - // Copy Stages from DS to ODS - for (int i = firstColorStageIdx; i < drawState.numColorStages(); ++i) { + // Copy Stages from PipelineBuilder to Pipeline + for (int i = firstColorStageIdx; i < pipelineBuilder.numColorStages(); ++i) { SkNEW_APPEND_TO_TARRAY(&fFragmentStages, GrPendingFragmentStage, - (drawState.fColorStages[i])); + (pipelineBuilder.fColorStages[i])); usesLocalCoords = usesLocalCoords || - drawState.fColorStages[i].processor()->usesLocalCoords(); + pipelineBuilder.fColorStages[i].processor()->usesLocalCoords(); } fNumColorStages = fFragmentStages.count(); - for (int i = firstCoverageStageIdx; i < drawState.numCoverageStages(); ++i) { + for (int i = firstCoverageStageIdx; i < pipelineBuilder.numCoverageStages(); ++i) { SkNEW_APPEND_TO_TARRAY(&fFragmentStages, GrPendingFragmentStage, - (drawState.fCoverageStages[i])); + (pipelineBuilder.fCoverageStages[i])); usesLocalCoords = usesLocalCoords || - drawState.fCoverageStages[i].processor()->usesLocalCoords(); + pipelineBuilder.fCoverageStages[i].processor()->usesLocalCoords(); } // let the GP init the batch tracker @@ -111,23 +111,23 @@ GrOptDrawState::GrOptDrawState(const GrDrawState& drawState, fInitBT.fUsesLocalCoords = usesLocalCoords; } -void GrOptDrawState::adjustProgramFromOptimizations(const GrDrawState& ds, - GrXferProcessor::OptFlags flags, - const GrProcOptInfo& colorPOI, - const GrProcOptInfo& coveragePOI, - int* firstColorStageIdx, - int* firstCoverageStageIdx) { +void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelineBuilder, + GrXferProcessor::OptFlags flags, + const GrProcOptInfo& colorPOI, + const GrProcOptInfo& coveragePOI, + int* firstColorStageIdx, + int* firstCoverageStageIdx) { fDescInfo.fReadsFragPosition = false; if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) || (flags & GrXferProcessor::kOverrideColor_OptFlag)) { - *firstColorStageIdx = ds.numColorStages(); + *firstColorStageIdx = pipelineBuilder.numColorStages(); } else { fDescInfo.fReadsFragPosition = colorPOI.readsFragPosition(); } if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) { - *firstCoverageStageIdx = ds.numCoverageStages(); + *firstCoverageStageIdx = pipelineBuilder.numCoverageStages(); } else { if (coveragePOI.readsFragPosition()) { fDescInfo.fReadsFragPosition = true; @@ -137,7 +137,7 @@ void GrOptDrawState::adjustProgramFromOptimizations(const GrDrawState& ds, //////////////////////////////////////////////////////////////////////////////// -bool GrOptDrawState::isEqual(const GrOptDrawState& that) const { +bool GrPipeline::isEqual(const GrPipeline& that) const { if (this->getRenderTarget() != that.getRenderTarget() || this->fFragmentStages.count() != that.fFragmentStages.count() || this->fNumColorStages != that.fNumColorStages || diff --git a/src/gpu/GrOptDrawState.h b/src/gpu/GrPipeline.h index 626e6d7c61..df654ba407 100644 --- a/src/gpu/GrOptDrawState.h +++ b/src/gpu/GrPipeline.h @@ -1,12 +1,12 @@ /* - * Copyright 2014 Google Inc. + * Copyright 2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ -#ifndef GrOptDrawState_DEFINED -#define GrOptDrawState_DEFINED +#ifndef GrPipeline_DEFINED +#define GrPipeline_DEFINED #include "GrColor.h" #include "GrGpu.h" @@ -18,26 +18,26 @@ #include "SkRefCnt.h" class GrDeviceCoordTexture; -class GrDrawState; class GrPathProcessor; +class GrPipelineBuilder; /** - * Class that holds an optimized version of a GrDrawState. It is meant to be an immutable class, - * and contains all data needed to set the state for a gpu draw. + * Class that holds an optimized version of a GrPipelineBuilder. It is meant to be an immutable + * class, and contains all data needed to set the state for a gpu draw. */ -class GrOptDrawState { +class GrPipeline { public: - SK_DECLARE_INST_COUNT(GrOptDrawState) + SK_DECLARE_INST_COUNT(GrPipeline) - GrOptDrawState(const GrDrawState& drawState, const GrPrimitiveProcessor*, - const GrDrawTargetCaps&, const GrScissorState&, - const GrDeviceCoordTexture* dstCopy); + GrPipeline(const GrPipelineBuilder& pipelineBuilder, const GrPrimitiveProcessor*, + const GrDrawTargetCaps&, const GrScissorState&, + const GrDeviceCoordTexture* dstCopy); /* - * Returns true if it is possible to combine the two GrOptDrawStates and it will update 'this' + * Returns true if it is possible to combine the two GrPipelines and it will update 'this' * to subsume 'that''s draw. */ - bool isEqual(const GrOptDrawState& that) const; + bool isEqual(const GrPipeline& that) const; /// @} @@ -122,7 +122,7 @@ public: * or both faces. * @return the current draw face(s). */ - GrDrawState::DrawFace getDrawFace() const { return fDrawFace; } + GrPipelineBuilder::DrawFace getDrawFace() const { return fDrawFace; } /// @} @@ -138,7 +138,7 @@ private: /** * Alter the program desc and inputs (attribs and processors) based on the blend optimization. */ - void adjustProgramFromOptimizations(const GrDrawState& ds, + void adjustProgramFromOptimizations(const GrPipelineBuilder& ds, GrXferProcessor::OptFlags, const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI, @@ -150,7 +150,7 @@ private: * the function may adjust the blend coefficients. After this function is called the src and dst * blend coeffs will represent those used by backend API. */ - void setOutputStateInfo(const GrDrawState& ds, GrXferProcessor::OptFlags, + void setOutputStateInfo(const GrPipelineBuilder& ds, GrXferProcessor::OptFlags, const GrDrawTargetCaps&); enum Flags { @@ -164,7 +164,7 @@ private: RenderTarget fRenderTarget; GrScissorState fScissorState; GrStencilSettings fStencilSettings; - GrDrawState::DrawFace fDrawFace; + GrPipelineBuilder::DrawFace fDrawFace; GrDeviceCoordTexture fDstCopy; uint32_t fFlags; ProgramXferProcessor fXferProcessor; diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrPipelineBuilder.cpp index db703935ca..f329c05b91 100644 --- a/src/gpu/GrDrawState.cpp +++ b/src/gpu/GrPipelineBuilder.cpp @@ -1,20 +1,20 @@ /* - * Copyright 2012 Google Inc. + * Copyright 2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ -#include "GrDrawState.h" +#include "GrPipelineBuilder.h" #include "GrBlend.h" -#include "GrOptDrawState.h" #include "GrPaint.h" +#include "GrPipeline.h" #include "GrProcOptInfo.h" #include "GrXferProcessor.h" #include "effects/GrPorterDuffXferProcessor.h" -GrDrawState::GrDrawState() +GrPipelineBuilder::GrPipelineBuilder() : fFlagBits(0x0) , fDrawFace(kBoth_DrawFace) , fColorProcInfoValid(false) @@ -26,7 +26,7 @@ GrDrawState::GrDrawState() SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) } -GrDrawState& GrDrawState::operator=(const GrDrawState& that) { +GrPipelineBuilder& GrPipelineBuilder::operator=(const GrPipelineBuilder& that) { fRenderTarget.reset(SkSafeRef(that.fRenderTarget.get())); fFlagBits = that.fFlagBits; fStencilSettings = that.fStencilSettings; @@ -50,7 +50,7 @@ GrDrawState& GrDrawState::operator=(const GrDrawState& that) { return *this; } -void GrDrawState::setFromPaint(const GrPaint& paint, GrRenderTarget* rt) { +void GrPipelineBuilder::setFromPaint(const GrPaint& paint, GrRenderTarget* rt) { SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numFragmentStages()); fColorStages.reset(); @@ -74,10 +74,10 @@ void GrDrawState::setFromPaint(const GrPaint& paint, GrRenderTarget* rt) { fFlagBits = 0; // Enable the clip bit - this->enableState(GrDrawState::kClip_StateBit); + this->enableState(GrPipelineBuilder::kClip_StateBit); - this->setState(GrDrawState::kDither_StateBit, paint.isDither()); - this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias()); + this->setState(GrPipelineBuilder::kDither_StateBit, paint.isDither()); + this->setState(GrPipelineBuilder::kHWAntialias_StateBit, paint.isAntiAlias()); fColorProcInfoValid = false; fCoverageProcInfoValid = false; @@ -91,7 +91,8 @@ void GrDrawState::setFromPaint(const GrPaint& paint, GrRenderTarget* rt) { //////////////////////////////////////////////////////////////////////////////// -bool GrDrawState::canUseFracCoveragePrimProc(GrColor color, const GrDrawTargetCaps& caps) const { +bool GrPipelineBuilder::canUseFracCoveragePrimProc(GrColor color, + const GrDrawTargetCaps& caps) const { if (caps.dualSourceBlendingSupport()) { return true; } @@ -107,30 +108,30 @@ bool GrDrawState::canUseFracCoveragePrimProc(GrColor color, const GrDrawTargetCa //////////////////////////////////////////////////////////////////////////////s -bool GrDrawState::willEffectReadDstColor() const { +bool GrPipelineBuilder::willEffectReadDstColor() const { return this->getXPFactory()->willReadDst(); } -void GrDrawState::AutoRestoreEffects::set(GrDrawState* ds) { - if (fDrawState) { - int m = fDrawState->numColorStages() - fColorEffectCnt; +void GrPipelineBuilder::AutoRestoreEffects::set(GrPipelineBuilder* pipelineBuilder) { + if (fPipelineBuilder) { + int m = fPipelineBuilder->numColorStages() - fColorEffectCnt; SkASSERT(m >= 0); - fDrawState->fColorStages.pop_back_n(m); + fPipelineBuilder->fColorStages.pop_back_n(m); - int n = fDrawState->numCoverageStages() - fCoverageEffectCnt; + int n = fPipelineBuilder->numCoverageStages() - fCoverageEffectCnt; SkASSERT(n >= 0); - fDrawState->fCoverageStages.pop_back_n(n); + fPipelineBuilder->fCoverageStages.pop_back_n(n); if (m + n > 0) { - fDrawState->fColorProcInfoValid = false; - fDrawState->fCoverageProcInfoValid = false; + fPipelineBuilder->fColorProcInfoValid = false; + fPipelineBuilder->fCoverageProcInfoValid = false; } - SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;) + SkDEBUGCODE(--fPipelineBuilder->fBlockEffectRemovalCnt;) } - fDrawState = ds; - if (NULL != ds) { - fColorEffectCnt = ds->numColorStages(); - fCoverageEffectCnt = ds->numCoverageStages(); - SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;) + fPipelineBuilder = pipelineBuilder; + if (NULL != pipelineBuilder) { + fColorEffectCnt = pipelineBuilder->numColorStages(); + fCoverageEffectCnt = pipelineBuilder->numCoverageStages(); + SkDEBUGCODE(++pipelineBuilder->fBlockEffectRemovalCnt;) } } @@ -138,19 +139,19 @@ void GrDrawState::AutoRestoreEffects::set(GrDrawState* ds) { // Some blend modes allow folding a fractional coverage value into the color's alpha channel, while // others will blend incorrectly. -bool GrDrawState::canTweakAlphaForCoverage() const { +bool GrPipelineBuilder::canTweakAlphaForCoverage() const { return this->getXPFactory()->canTweakAlphaForCoverage(); } //////////////////////////////////////////////////////////////////////////////// -GrDrawState::~GrDrawState() { +GrPipelineBuilder::~GrPipelineBuilder() { SkASSERT(0 == fBlockEffectRemovalCnt); } //////////////////////////////////////////////////////////////////////////////// -bool GrDrawState::willBlendWithDst(const GrPrimitiveProcessor* pp) const { +bool GrPipelineBuilder::willBlendWithDst(const GrPrimitiveProcessor* pp) const { this->calcColorInvariantOutput(pp); this->calcCoverageInvariantOutput(pp); @@ -159,7 +160,7 @@ bool GrDrawState::willBlendWithDst(const GrPrimitiveProcessor* pp) const { return output.fWillBlendWithDst; } -void GrDrawState::calcColorInvariantOutput(const GrPrimitiveProcessor* pp) const { +void GrPipelineBuilder::calcColorInvariantOutput(const GrPrimitiveProcessor* pp) const { if (!fColorProcInfoValid || fColorPrimProc != pp) { fColorProcInfo.calcColorWithPrimProc(pp, fColorStages.begin(), this->numColorStages()); fColorProcInfoValid = true; @@ -167,7 +168,7 @@ void GrDrawState::calcColorInvariantOutput(const GrPrimitiveProcessor* pp) const } } -void GrDrawState::calcCoverageInvariantOutput(const GrPrimitiveProcessor* pp) const { +void GrPipelineBuilder::calcCoverageInvariantOutput(const GrPrimitiveProcessor* pp) const { if (!fCoverageProcInfoValid || fCoveragePrimProc != pp) { fCoverageProcInfo.calcCoverageWithPrimProc(pp, fCoverageStages.begin(), this->numCoverageStages()); @@ -176,7 +177,7 @@ void GrDrawState::calcCoverageInvariantOutput(const GrPrimitiveProcessor* pp) co } } -void GrDrawState::calcColorInvariantOutput(GrColor color) const { +void GrPipelineBuilder::calcColorInvariantOutput(GrColor color) const { if (!fColorProcInfoValid || color != fColorCache) { GrColorComponentFlags flags = kRGBA_GrColorComponentFlags; fColorProcInfo.calcWithInitialValues(fColorStages.begin(), this->numColorStages(), color, @@ -186,7 +187,7 @@ void GrDrawState::calcColorInvariantOutput(GrColor color) const { } } -void GrDrawState::calcCoverageInvariantOutput(GrColor coverage) const { +void GrPipelineBuilder::calcCoverageInvariantOutput(GrColor coverage) const { if (!fCoverageProcInfoValid || coverage != fCoverageCache) { GrColorComponentFlags flags = kRGBA_GrColorComponentFlags; fCoverageProcInfo.calcWithInitialValues(fCoverageStages.begin(), diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrPipelineBuilder.h index 45fc574bde..9579024d6a 100644 --- a/src/gpu/GrDrawState.h +++ b/src/gpu/GrPipelineBuilder.h @@ -1,12 +1,12 @@ /* - * Copyright 2011 Google Inc. + * Copyright 2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ -#ifndef GrDrawState_DEFINED -#define GrDrawState_DEFINED +#ifndef GrPipelineBuilder_DEFINED +#define GrPipelineBuilder_DEFINED #include "GrBlend.h" @@ -28,24 +28,22 @@ class GrDrawTargetCaps; class GrPaint; class GrTexture; -class GrDrawState { +class GrPipelineBuilder { public: - GrDrawState(); - /** - * Copies another draw state. - **/ - GrDrawState(const GrDrawState& state) { + GrPipelineBuilder(); + + GrPipelineBuilder(const GrPipelineBuilder& pipelineBuilder) { SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) - *this = state; + *this = pipelineBuilder; } - virtual ~GrDrawState(); + virtual ~GrPipelineBuilder(); /** - * Initializes the GrDrawState based on a GrPaint, view matrix and render target. Note that - * GrDrawState encompasses more than GrPaint. Aspects of GrDrawState that have no GrPaint - * equivalents are set to default values with the exception of vertex attribute state which - * is unmodified by this function and clipping which will be enabled. + * Initializes the GrPipelineBuilder based on a GrPaint, view matrix and render target. Note + * that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have + * no GrPaint equivalents are set to default values with the exception of vertex attribute state + * which is unmodified by this function and clipping which will be enabled. */ void setFromPaint(const GrPaint&, GrRenderTarget*); @@ -56,7 +54,7 @@ public: * it may or may not be possible to correctly blend with fractional pixel coverage generated by * the fragment shader. * - * This function considers the current draw state and the draw target's capabilities to + * This function considers the current GrPipelineBuilder and the draw target's capabilities to * determine whether coverage can be handled correctly. This function assumes that the caller * intends to specify fractional pixel coverage via a primitive processor but may not have * specified it yet. @@ -171,30 +169,23 @@ public: } /** - * When this object is destroyed it will remove any color/coverage effects from the draw state - * that were added after its constructor. - * - * This class has strange behavior around geometry processor. If there is a GP on the draw state - * it will assert that the GP is not modified until after the destructor of the ARE. If the - * draw state has a NULL GP when the ARE is constructed then it will reset it to null in the - * destructor. + * When this object is destroyed it will remove any color/coverage effects from the pipeline + * builder that were added after its constructor. * - * TODO: We'd prefer for the ARE to just save and restore the GP. However, this would add - * significant complexity to the multi-ref architecture for deferred drawing. Once GrDrawState - * and GrOptDrawState are fully separated then GrDrawState will never be in the deferred - * execution state and GrOptDrawState always will be (and will be immutable and therefore - * unable to have an ARE). At this point we can restore sanity and have the ARE save and restore - * the GP. + * This class has strange behavior around geometry processor. If there is a GP on the + * GrPipelineBuilder it will assert that the GP is not modified until after the destructor of + * the ARE. If the GrPipelineBuilder has a NULL GP when the ARE is constructed then it will reset + * it to null in the destructor. */ class AutoRestoreEffects : public ::SkNoncopyable { public: AutoRestoreEffects() - : fDrawState(NULL) + : fPipelineBuilder(NULL) , fColorEffectCnt(0) , fCoverageEffectCnt(0) {} - AutoRestoreEffects(GrDrawState* ds) - : fDrawState(NULL) + AutoRestoreEffects(GrPipelineBuilder* ds) + : fPipelineBuilder(NULL) , fColorEffectCnt(0) , fCoverageEffectCnt(0) { this->set(ds); @@ -202,12 +193,12 @@ public: ~AutoRestoreEffects() { this->set(NULL); } - void set(GrDrawState* ds); + void set(GrPipelineBuilder* ds); - bool isSet() const { return SkToBool(fDrawState); } + bool isSet() const { return SkToBool(fPipelineBuilder); } private: - GrDrawState* fDrawState; + GrPipelineBuilder* fPipelineBuilder; int fColorEffectCnt; int fCoverageEffectCnt; }; @@ -219,27 +210,27 @@ public: */ class AutoRestoreStencil : public ::SkNoncopyable { public: - AutoRestoreStencil() : fDrawState(NULL) {} + AutoRestoreStencil() : fPipelineBuilder(NULL) {} - AutoRestoreStencil(GrDrawState* ds) : fDrawState(NULL) { this->set(ds); } + AutoRestoreStencil(GrPipelineBuilder* ds) : fPipelineBuilder(NULL) { this->set(ds); } ~AutoRestoreStencil() { this->set(NULL); } - void set(GrDrawState* ds) { - if (fDrawState) { - fDrawState->setStencil(fStencilSettings); + void set(GrPipelineBuilder* ds) { + if (fPipelineBuilder) { + fPipelineBuilder->setStencil(fStencilSettings); } - fDrawState = ds; + fPipelineBuilder = ds; if (ds) { fStencilSettings = ds->getStencil(); } } - bool isSet() const { return SkToBool(fDrawState); } + bool isSet() const { return SkToBool(fPipelineBuilder); } private: - GrDrawState* fDrawState; - GrStencilSettings fStencilSettings; + GrPipelineBuilder* fPipelineBuilder; + GrStencilSettings fStencilSettings; }; /// @} @@ -397,7 +388,7 @@ public: /////////////////////////////////////////////////////////////////////////// - GrDrawState& operator= (const GrDrawState& that); + GrPipelineBuilder& operator= (const GrPipelineBuilder& that); private: const GrProcOptInfo& colorProcInfo(const GrPrimitiveProcessor* pp) const { @@ -457,7 +448,7 @@ private: mutable const GrPrimitiveProcessor* fColorPrimProc; mutable const GrPrimitiveProcessor* fCoveragePrimProc; - friend class GrOptDrawState; + friend class GrPipeline; }; #endif diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp index 21c935236d..2345eda077 100644 --- a/src/gpu/GrSWMaskHelper.cpp +++ b/src/gpu/GrSWMaskHelper.cpp @@ -7,7 +7,7 @@ #include "GrSWMaskHelper.h" -#include "GrDrawState.h" +#include "GrPipelineBuilder.h" #include "GrDrawTargetCaps.h" #include "GrGpu.h" @@ -347,7 +347,7 @@ GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context, void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture, GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkIRect& rect) { @@ -355,7 +355,7 @@ void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture, if (!viewMatrix.invert(&invert)) { return; } - GrDrawState::AutoRestoreEffects are(drawState); + GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder); SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft, SK_Scalar1 * rect.fTop, @@ -369,11 +369,11 @@ void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture, maskMatrix.setIDiv(texture->width(), texture->height()); maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop)); - drawState->addCoverageProcessor( + pipelineBuilder->addCoverageProcessor( GrSimpleTextureEffect::Create(texture, maskMatrix, GrTextureParams::kNone_FilterMode, kDevice_GrCoordSet))->unref(); - target->drawRect(drawState, color, SkMatrix::I(), dstRect, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), dstRect, NULL, &invert); } diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h index 71dec6357d..c18097122b 100644 --- a/src/gpu/GrSWMaskHelper.h +++ b/src/gpu/GrSWMaskHelper.h @@ -9,7 +9,7 @@ #define GrSWMaskHelper_DEFINED #include "GrColor.h" -#include "GrDrawState.h" +#include "GrPipelineBuilder.h" #include "SkBitmap.h" #include "SkDraw.h" #include "SkMatrix.h" @@ -92,7 +92,7 @@ public: // output of DrawPathMaskToTexture. static void DrawToTargetWithPathMask(GrTexture* texture, GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor, const SkMatrix& viewMatrix, const SkIRect& rect); diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp index 90b35f7431..4fb7538b03 100644 --- a/src/gpu/GrSoftwarePathRenderer.cpp +++ b/src/gpu/GrSoftwarePathRenderer.cpp @@ -12,7 +12,7 @@ //////////////////////////////////////////////////////////////////////////////// bool GrSoftwarePathRenderer::canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -26,7 +26,7 @@ bool GrSoftwarePathRenderer::canDrawPath(const GrDrawTarget*, GrPathRenderer::StencilSupport GrSoftwarePathRenderer::onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const { return GrPathRenderer::kNoSupport_StencilSupport; @@ -39,13 +39,13 @@ namespace { // path bounds will be a subset of the clip bounds. returns false if // path bounds would be empty. bool get_path_and_clip_bounds(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkPath& path, const SkMatrix& matrix, SkIRect* devPathBounds, SkIRect* devClipBounds) { // compute bounds as intersection of rt size, clip, and path - const GrRenderTarget* rt = drawState->getRenderTarget(); + const GrRenderTarget* rt = pipelineBuilder->getRenderTarget(); if (NULL == rt) { return false; } @@ -78,7 +78,7 @@ bool get_path_and_clip_bounds(const GrDrawTarget* target, //////////////////////////////////////////////////////////////////////////////// void draw_around_inv_path(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkIRect& devClipBounds, @@ -92,22 +92,22 @@ void draw_around_inv_path(GrDrawTarget* target, if (devClipBounds.fTop < devPathBounds.fTop) { rect.iset(devClipBounds.fLeft, devClipBounds.fTop, devClipBounds.fRight, devPathBounds.fTop); - target->drawRect(drawState, color, SkMatrix::I(), rect, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), rect, NULL, &invert); } if (devClipBounds.fLeft < devPathBounds.fLeft) { rect.iset(devClipBounds.fLeft, devPathBounds.fTop, devPathBounds.fLeft, devPathBounds.fBottom); - target->drawRect(drawState, color, SkMatrix::I(), rect, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), rect, NULL, &invert); } if (devClipBounds.fRight > devPathBounds.fRight) { rect.iset(devPathBounds.fRight, devPathBounds.fTop, devClipBounds.fRight, devPathBounds.fBottom); - target->drawRect(drawState, color, SkMatrix::I(), rect, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), rect, NULL, &invert); } if (devClipBounds.fBottom > devPathBounds.fBottom) { rect.iset(devClipBounds.fLeft, devPathBounds.fBottom, devClipBounds.fRight, devClipBounds.fBottom); - target->drawRect(drawState, color, SkMatrix::I(), rect, NULL, &invert); + target->drawRect(pipelineBuilder, color, SkMatrix::I(), rect, NULL, &invert); } } @@ -116,7 +116,7 @@ void draw_around_inv_path(GrDrawTarget* target, //////////////////////////////////////////////////////////////////////////////// // return true on success; false on failure bool GrSoftwarePathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -128,10 +128,11 @@ bool GrSoftwarePathRenderer::onDrawPath(GrDrawTarget* target, } SkIRect devPathBounds, devClipBounds; - if (!get_path_and_clip_bounds(target, drawState, path, viewMatrix, + if (!get_path_and_clip_bounds(target, pipelineBuilder, path, viewMatrix, &devPathBounds, &devClipBounds)) { if (path.isInverseFillType()) { - draw_around_inv_path(target, drawState, color, viewMatrix, devClipBounds,devPathBounds); + draw_around_inv_path(target, pipelineBuilder, color, viewMatrix, devClipBounds, + devPathBounds); } return true; } @@ -144,12 +145,13 @@ bool GrSoftwarePathRenderer::onDrawPath(GrDrawTarget* target, return false; } - GrDrawState copy = *drawState; + GrPipelineBuilder copy = *pipelineBuilder; GrSWMaskHelper::DrawToTargetWithPathMask(texture, target, ©, color, viewMatrix, devPathBounds); if (path.isInverseFillType()) { - draw_around_inv_path(target, drawState, color, viewMatrix, devClipBounds, devPathBounds); + draw_around_inv_path(target, pipelineBuilder, color, viewMatrix, devClipBounds, + devPathBounds); } return true; diff --git a/src/gpu/GrSoftwarePathRenderer.h b/src/gpu/GrSoftwarePathRenderer.h index 43d5e55ce9..ed897cceaf 100644 --- a/src/gpu/GrSoftwarePathRenderer.h +++ b/src/gpu/GrSoftwarePathRenderer.h @@ -24,19 +24,19 @@ public: } virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, bool antiAlias) const SK_OVERRIDE; protected: virtual StencilSupport onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const SK_OVERRIDE; virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, diff --git a/src/gpu/GrStencilAndCoverPathRenderer.cpp b/src/gpu/GrStencilAndCoverPathRenderer.cpp index 207194dd79..1a3856c801 100644 --- a/src/gpu/GrStencilAndCoverPathRenderer.cpp +++ b/src/gpu/GrStencilAndCoverPathRenderer.cpp @@ -51,20 +51,20 @@ GrStencilAndCoverPathRenderer::~GrStencilAndCoverPathRenderer() { } bool GrStencilAndCoverPathRenderer::canDrawPath(const GrDrawTarget* target, - const GrDrawState* drawState, + const GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke, bool antiAlias) const { return !stroke.isHairlineStyle() && !antiAlias && // doesn't do per-path AA, relies on the target having MSAA - drawState->getRenderTarget()->getStencilBuffer() && - drawState->getStencil().isDisabled(); + pipelineBuilder->getRenderTarget()->getStencilBuffer() && + pipelineBuilder->getStencil().isDisabled(); } GrPathRenderer::StencilSupport GrStencilAndCoverPathRenderer::onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const { return GrPathRenderer::kStencilOnly_StencilSupport; @@ -82,18 +82,18 @@ static GrPath* get_gr_path(GrGpu* gpu, const SkPath& skPath, const SkStrokeRec& } void GrStencilAndCoverPathRenderer::onStencilPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, const SkMatrix& viewMatrix, const SkPath& path, const SkStrokeRec& stroke) { SkASSERT(!path.isInverseFillType()); SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(GrColor_WHITE, viewMatrix)); SkAutoTUnref<GrPath> p(get_gr_path(fGpu, path, stroke)); - target->stencilPath(drawState, pp, p, convert_skpath_filltype(path.getFillType())); + target->stencilPath(pipelineBuilder, pp, p, convert_skpath_filltype(path.getFillType())); } bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target, - GrDrawState* drawState, + GrPipelineBuilder* pipelineBuilder, GrColor color, const SkMatrix& viewMatrix, const SkPath& path, @@ -102,7 +102,7 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target, SkASSERT(!antiAlias); SkASSERT(!stroke.isHairlineStyle()); - SkASSERT(drawState->getStencil().isDisabled()); + SkASSERT(pipelineBuilder->getStencil().isDisabled()); SkAutoTUnref<GrPath> p(get_gr_path(fGpu, path, stroke)); @@ -118,16 +118,16 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target, 0x0000, 0xffff); - drawState->setStencil(kInvertedStencilPass); + pipelineBuilder->setStencil(kInvertedStencilPass); // fake inverse with a stencil and cover SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(GrColor_WHITE, viewMatrix)); - target->stencilPath(drawState, pp, p, convert_skpath_filltype(path.getFillType())); + target->stencilPath(pipelineBuilder, pp, p, convert_skpath_filltype(path.getFillType())); SkMatrix invert = SkMatrix::I(); - SkRect bounds = SkRect::MakeLTRB(0, 0, - SkIntToScalar(drawState->getRenderTarget()->width()), - SkIntToScalar(drawState->getRenderTarget()->height())); + SkRect bounds = + SkRect::MakeLTRB(0, 0, SkIntToScalar(pipelineBuilder->getRenderTarget()->width()), + SkIntToScalar(pipelineBuilder->getRenderTarget()->height())); SkMatrix vmi; // mapRect through persp matrix may not be correct if (!viewMatrix.hasPerspective() && viewMatrix.invert(&vmi)) { @@ -142,7 +142,7 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target, } } const SkMatrix& viewM = viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix; - target->drawRect(drawState, color, viewM, bounds, NULL, &invert); + target->drawRect(pipelineBuilder, color, viewM, bounds, NULL, &invert); } else { GR_STATIC_CONST_SAME_STENCIL(kStencilPass, kZero_StencilOp, @@ -152,11 +152,11 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target, 0x0000, 0xffff); - drawState->setStencil(kStencilPass); + pipelineBuilder->setStencil(kStencilPass); SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(color, viewMatrix)); - target->drawPath(drawState, pp, p, convert_skpath_filltype(path.getFillType())); + target->drawPath(pipelineBuilder, pp, p, convert_skpath_filltype(path.getFillType())); } - drawState->stencil()->setDisabled(); + pipelineBuilder->stencil()->setDisabled(); return true; } diff --git a/src/gpu/GrStencilAndCoverPathRenderer.h b/src/gpu/GrStencilAndCoverPathRenderer.h index 1ea26c4e8e..cb4012f3d1 100644 --- a/src/gpu/GrStencilAndCoverPathRenderer.h +++ b/src/gpu/GrStencilAndCoverPathRenderer.h @@ -26,7 +26,7 @@ public: virtual ~GrStencilAndCoverPathRenderer(); virtual bool canDrawPath(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&, @@ -34,12 +34,12 @@ public: protected: virtual StencilSupport onGetStencilSupport(const GrDrawTarget*, - const GrDrawState*, + const GrPipelineBuilder*, const SkPath&, const SkStrokeRec&) const SK_OVERRIDE; virtual bool onDrawPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, GrColor, const SkMatrix& viewMatrix, const SkPath&, @@ -47,7 +47,7 @@ protected: bool antiAlias) SK_OVERRIDE; virtual void onStencilPath(GrDrawTarget*, - GrDrawState*, + GrPipelineBuilder*, const SkMatrix& viewMatrix, const SkPath&, const SkStrokeRec&) SK_OVERRIDE; diff --git a/src/gpu/GrStencilAndCoverTextContext.cpp b/src/gpu/GrStencilAndCoverTextContext.cpp index 6447ca523a..c29dca6d0a 100644 --- a/src/gpu/GrStencilAndCoverTextContext.cpp +++ b/src/gpu/GrStencilAndCoverTextContext.cpp @@ -344,9 +344,9 @@ void GrStencilAndCoverTextContext::init(const GrPaint& paint, &fGlyphCache->getDescriptor(), fStroke); } - fStateRestore.set(&fDrawState); + fStateRestore.set(&fPipelineBuilder); - fDrawState.setFromPaint(fPaint, fContext->getRenderTarget()); + fPipelineBuilder.setFromPaint(fPaint, fContext->getRenderTarget()); GR_STATIC_CONST_SAME_STENCIL(kStencilPass, kZero_StencilOp, @@ -356,7 +356,7 @@ void GrStencilAndCoverTextContext::init(const GrPaint& paint, 0x0000, 0xffff); - *fDrawState.stencil() = kStencilPass; + *fPipelineBuilder.stencil() = kStencilPass; SkASSERT(0 == fQueuedGlyphCount); SkASSERT(kGlyphBufferSize == fFallbackGlyphsIdx); @@ -408,7 +408,7 @@ void GrStencilAndCoverTextContext::flush() { SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(fPaint.getColor(), fViewMatrix, fLocalMatrix)); - fDrawTarget->drawPaths(&fDrawState, pp, fGlyphs, + fDrawTarget->drawPaths(&fPipelineBuilder, pp, fGlyphs, fGlyphIndices, GrPathRange::kU16_PathIndexType, get_xy_scalar_array(fGlyphPositions), GrPathRendering::kTranslate_PathTransformType, @@ -453,7 +453,7 @@ void GrStencilAndCoverTextContext::finish() { SkGlyphCache::AttachCache(fGlyphCache); fGlyphCache = NULL; - fDrawState.stencil()->setDisabled(); + fPipelineBuilder.stencil()->setDisabled(); fStateRestore.set(NULL); fViewMatrix = fContextInitialMatrix; GrTextContext::finish(); diff --git a/src/gpu/GrStencilAndCoverTextContext.h b/src/gpu/GrStencilAndCoverTextContext.h index c7b06cc104..345b3a5d5a 100644 --- a/src/gpu/GrStencilAndCoverTextContext.h +++ b/src/gpu/GrStencilAndCoverTextContext.h @@ -51,8 +51,8 @@ private: kMaxPerformance_RenderMode, }; - GrDrawState fDrawState; - GrDrawState::AutoRestoreEffects fStateRestore; + GrPipelineBuilder fPipelineBuilder; + GrPipelineBuilder::AutoRestoreEffects fStateRestore; SkScalar fTextRatio; float fTextInverseRatio; SkGlyphCache* fGlyphCache; diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp index 5ec4dcfa4f..ef2517dcf0 100644 --- a/src/gpu/GrTest.cpp +++ b/src/gpu/GrTest.cpp @@ -48,7 +48,7 @@ void GrContext::purgeAllUnlockedResources() { #include "GrInOrderDrawBuffer.h" #include "GrGpu.h" -class GrOptDrawState; +class GrPipeline; class MockGpu : public GrGpu { public: @@ -64,7 +64,7 @@ public: GrPixelConfig config, size_t rowBytes) const SK_OVERRIDE { return false; } void buildProgramDesc(GrProgramDesc*,const GrPrimitiveProcessor&, - const GrOptDrawState&, + const GrPipeline&, const GrProgramDesc::DescInfo&, const GrBatchTracker&) const SK_OVERRIDE {} diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp index 88ffad0c2e..4a034060de 100644 --- a/src/gpu/effects/GrDashingEffect.cpp +++ b/src/gpu/effects/GrDashingEffect.cpp @@ -28,9 +28,9 @@ // Returns whether or not the gpu can fast path the dash line effect. static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeInfo, - const GrDrawTarget& target, const GrDrawState& ds, + const GrDrawTarget& target, const GrPipelineBuilder& pipelineBuilder, const SkMatrix& viewMatrix) { - if (ds.getRenderTarget()->isMultisampled()) { + if (pipelineBuilder.getRenderTarget()->isMultisampled()) { return false; } @@ -164,10 +164,11 @@ static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& m matrix.mapPoints(&verts[idx], 4); } -bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState* drawState, - GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2], +bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, + GrPipelineBuilder* pipelineBuilder, GrColor color, + const SkMatrix& viewMatrix, const SkPoint pts[2], const GrPaint& paint, const GrStrokeInfo& strokeInfo) { - if (!can_fast_path_dash(pts, strokeInfo, *target, *drawState, viewMatrix)) { + if (!can_fast_path_dash(pts, strokeInfo, *target, *pipelineBuilder, viewMatrix)) { return false; } @@ -442,7 +443,8 @@ bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState } target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer()); - target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, totalRectCnt, 4, 6); + target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType, + totalRectCnt, 4, 6); target->resetIndexSource(); return true; } diff --git a/src/gpu/effects/GrDashingEffect.h b/src/gpu/effects/GrDashingEffect.h index 651a240add..5552f1df1b 100644 --- a/src/gpu/effects/GrDashingEffect.h +++ b/src/gpu/effects/GrDashingEffect.h @@ -14,18 +14,19 @@ #include "SkPathEffect.h" class GrGpu; -class GrDrawState; class GrDrawTarget; class GrGeometryProcessor; class GrPaint; +class GrPipelineBuilder; class GrStrokeInfo; class GrGLDashingEffect; class SkPath; namespace GrDashingEffect { - bool DrawDashLine(GrGpu*, GrDrawTarget*, GrDrawState*, GrColor, const SkMatrix& viewMatrix, - const SkPoint pts[2], const GrPaint& paint, const GrStrokeInfo& strokeInfo); + bool DrawDashLine(GrGpu*, GrDrawTarget*, GrPipelineBuilder*, GrColor, + const SkMatrix& viewMatrix, const SkPoint pts[2], const GrPaint& paint, + const GrStrokeInfo& strokeInfo); enum DashCap { kRound_DashCap, diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index b28c32e68c..f3aef13327 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -10,7 +10,7 @@ #include "GrGLStencilBuffer.h" #include "GrGLTextureRenderTarget.h" #include "GrGpuResourceCacheAccess.h" -#include "GrOptDrawState.h" +#include "GrPipeline.h" #include "GrSurfacePriv.h" #include "GrTemplates.h" #include "GrTexturePriv.h" @@ -242,7 +242,7 @@ void GrGLGpu::onResetContext(uint32_t resetBits) { GL_CALL(Disable(GR_GL_DEPTH_TEST)); GL_CALL(DepthMask(GR_GL_FALSE)); - fHWDrawFace = GrDrawState::kInvalid_DrawFace; + fHWDrawFace = GrPipelineBuilder::kInvalid_DrawFace; fHWDitherEnabled = kUnknown_TriState; if (kGL_GrGLStandard == this->glStandard()) { @@ -1338,12 +1338,12 @@ void GrGLGpu::flushScissor(const GrScissorState& scissorState, bool GrGLGpu::flushGLState(const DrawArgs& args, bool isLineDraw) { GrXferProcessor::BlendInfo blendInfo; - const GrOptDrawState& optState = *args.fOptState; - args.fOptState->getXferProcessor()->getBlendInfo(&blendInfo); + const GrPipeline& pipeline = *args.fPipeline; + args.fPipeline->getXferProcessor()->getBlendInfo(&blendInfo); - this->flushDither(optState.isDitherState()); + this->flushDither(pipeline.isDitherState()); this->flushColorWrite(blendInfo.fWriteColor); - this->flushDrawFace(optState.getDrawFace()); + this->flushDrawFace(pipeline.getDrawFace()); fCurrentProgram.reset(fProgramCache->getProgram(args)); if (NULL == fCurrentProgram.get()) { @@ -1363,12 +1363,12 @@ bool GrGLGpu::flushGLState(const DrawArgs& args, bool isLineDraw) { this->flushBlend(blendInfo); } - fCurrentProgram->setData(*args.fPrimitiveProcessor, optState, *args.fBatchTracker); + fCurrentProgram->setData(*args.fPrimitiveProcessor, pipeline, *args.fBatchTracker); - GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget()); - this->flushStencil(optState.getStencil()); - this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin()); - this->flushHWAAState(glRT, optState.isHWAntialiasState(), isLineDraw); + GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(pipeline.getRenderTarget()); + this->flushStencil(pipeline.getStencil()); + this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), glRT->origin()); + this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), isLineDraw); // This must come after textures are flushed because a texture may need // to be msaa-resolved (which will modify bound FBO state). @@ -1432,10 +1432,10 @@ void GrGLGpu::setupGeometry(const GrPrimitiveProcessor& primProc, void GrGLGpu::buildProgramDesc(GrProgramDesc* desc, const GrPrimitiveProcessor& primProc, - const GrOptDrawState& optState, + const GrPipeline& pipeline, const GrProgramDesc::DescInfo& descInfo, const GrBatchTracker& batchTracker) const { - if (!GrGLProgramDescBuilder::Build(desc, primProc, optState, descInfo, this, + if (!GrGLProgramDescBuilder::Build(desc, primProc, pipeline, descInfo, this, batchTracker)) { SkDEBUGFAIL("Failed to generate GL program descriptor"); } @@ -1864,7 +1864,7 @@ void GrGLGpu::onDraw(const DrawArgs& args, const GrDrawTarget::DrawInfo& info) { void GrGLGpu::onStencilPath(const GrPath* path, const StencilPathState& state) { this->flushColorWrite(false); - this->flushDrawFace(GrDrawState::kBoth_DrawFace); + this->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace); GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(state.fRenderTarget); SkISize size = SkISize::Make(rt->width(), rt->height()); @@ -2234,18 +2234,18 @@ void GrGLGpu::flushColorWrite(bool writeColor) { } } -void GrGLGpu::flushDrawFace(GrDrawState::DrawFace face) { +void GrGLGpu::flushDrawFace(GrPipelineBuilder::DrawFace face) { if (fHWDrawFace != face) { switch (face) { - case GrDrawState::kCCW_DrawFace: + case GrPipelineBuilder::kCCW_DrawFace: GL_CALL(Enable(GR_GL_CULL_FACE)); GL_CALL(CullFace(GR_GL_BACK)); break; - case GrDrawState::kCW_DrawFace: + case GrPipelineBuilder::kCW_DrawFace: GL_CALL(Enable(GR_GL_CULL_FACE)); GL_CALL(CullFace(GR_GL_FRONT)); break; - case GrDrawState::kBoth_DrawFace: + case GrPipelineBuilder::kBoth_DrawFace: GL_CALL(Disable(GR_GL_CULL_FACE)); break; default: diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h index 0173a23c48..9b4f0671b3 100644 --- a/src/gpu/gl/GrGLGpu.h +++ b/src/gpu/gl/GrGLGpu.h @@ -8,7 +8,6 @@ #ifndef GrGLGpu_DEFINED #define GrGLGpu_DEFINED -#include "GrDrawState.h" #include "GrGLContext.h" #include "GrGLIRect.h" #include "GrGLIndexBuffer.h" @@ -20,10 +19,12 @@ #include "GrGLVertexArray.h" #include "GrGLVertexBuffer.h" #include "GrGpu.h" -#include "GrOptDrawState.h" +#include "GrPipelineBuilder.h" #include "GrXferProcessor.h" #include "SkTypes.h" +class GrPipeline; + #ifdef SK_DEVELOPER #define PROGRAM_CACHE_STATS #endif @@ -106,7 +107,7 @@ public: void buildProgramDesc(GrProgramDesc*, const GrPrimitiveProcessor&, - const GrOptDrawState&, + const GrPipeline&, const GrProgramDesc::DescInfo&, const GrBatchTracker&) const SK_OVERRIDE; @@ -166,7 +167,7 @@ private: // binds texture unit in GL void setTextureUnit(int unitIdx); - // Flushes state from GrOptDrawState to GL. Returns false if the state couldn't be set. + // Flushes state from GrPipeline to GL. Returns false if the state couldn't be set. // TODO we only have need to know if this is a line draw for flushing AA state on some buggy // hardware. Evaluate if this is really necessary anymore bool flushGLState(const DrawArgs&, bool isLineDraw); @@ -227,7 +228,7 @@ private: void flushDither(bool dither); void flushColorWrite(bool writeColor); - void flushDrawFace(GrDrawState::DrawFace face); + void flushDrawFace(GrPipelineBuilder::DrawFace face); // flushes the scissor. see the note on flushBoundTextureAndParams about // flushing the scissor after that function is called. @@ -443,7 +444,7 @@ private: TriState fHWStencilTestEnabled; - GrDrawState::DrawFace fHWDrawFace; + GrPipelineBuilder::DrawFace fHWDrawFace; TriState fHWWriteToColor; TriState fHWDitherEnabled; uint32_t fHWBoundRenderTargetUniqueID; diff --git a/src/gpu/gl/GrGLGpuProgramCache.cpp b/src/gpu/gl/GrGLGpuProgramCache.cpp index 3e20047be7..911fd936e8 100644 --- a/src/gpu/gl/GrGLGpuProgramCache.cpp +++ b/src/gpu/gl/GrGLGpuProgramCache.cpp @@ -11,7 +11,6 @@ #include "GrProcessor.h" #include "GrGLProcessor.h" #include "GrGLPathRendering.h" -#include "GrOptDrawState.h" #include "SkRTConf.h" #include "SkTSearch.h" diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp index c018cfe6c1..ad63dc4ea7 100644 --- a/src/gpu/gl/GrGLProgram.cpp +++ b/src/gpu/gl/GrGLProgram.cpp @@ -17,7 +17,7 @@ #include "GrGLPathRendering.h" #include "GrGLShaderVar.h" #include "GrGLSL.h" -#include "GrOptDrawState.h" +#include "GrPipeline.h" #include "GrXferProcessor.h" #include "SkXfermode.h" @@ -103,11 +103,11 @@ void GrGLProgram::bindTextures(const Proc* ip, const GrProcessor& processor) { /////////////////////////////////////////////////////////////////////////////// -void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrOptDrawState& optState, +void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrPipeline& pipeline, const GrBatchTracker& batchTracker) { - this->setRenderTargetState(primProc, optState); + this->setRenderTargetState(primProc, pipeline); - const GrDeviceCoordTexture* dstCopy = optState.getDstCopy(); + const GrDeviceCoordTexture* dstCopy = pipeline.getDstCopy(); if (dstCopy) { if (fBuiltinUniformHandles.fDstCopyTopLeftUni.isValid()) { fProgramDataManager.set2f(fBuiltinUniformHandles.fDstCopyTopLeftUni, @@ -135,21 +135,21 @@ void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrOptDrawS this->bindTextures(fGeometryProcessor.get(), primProc); if (fXferProcessor.get()) { - const GrXferProcessor& xp = *optState.getXferProcessor(); + const GrXferProcessor& xp = *pipeline.getXferProcessor(); fXferProcessor->fGLProc->setData(fProgramDataManager, xp); this->bindTextures(fXferProcessor.get(), xp); } - this->setFragmentData(primProc, optState); + this->setFragmentData(primProc, pipeline); // Some of GrGLProgram subclasses need to update state here this->didSetData(); } void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc, - const GrOptDrawState& optState) { + const GrPipeline& pipeline) { int numProcessors = fFragmentProcessors->fProcs.count(); for (int e = 0; e < numProcessors; ++e) { - const GrPendingFragmentStage& stage = optState.getFragmentStage(e); + const GrPendingFragmentStage& stage = pipeline.getFragmentStage(e); const GrProcessor& processor = *stage.processor(); fFragmentProcessors->fProcs[e]->fGLProc->setData(fProgramDataManager, processor); this->setTransformData(primProc, @@ -170,21 +170,21 @@ void GrGLProgram::setTransformData(const GrPrimitiveProcessor& primProc, } void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc, - const GrOptDrawState& optState) { + const GrPipeline& pipeline) { // Load the RT height uniform if it is needed to y-flip gl_FragCoord. if (fBuiltinUniformHandles.fRTHeightUni.isValid() && - fRenderTargetState.fRenderTargetSize.fHeight != optState.getRenderTarget()->height()) { + fRenderTargetState.fRenderTargetSize.fHeight != pipeline.getRenderTarget()->height()) { fProgramDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, - SkIntToScalar(optState.getRenderTarget()->height())); + SkIntToScalar(pipeline.getRenderTarget()->height())); } // call subclasses to set the actual view matrix - this->onSetRenderTargetState(primProc, optState); + this->onSetRenderTargetState(primProc, pipeline); } void GrGLProgram::onSetRenderTargetState(const GrPrimitiveProcessor&, - const GrOptDrawState& optState) { - const GrRenderTarget* rt = optState.getRenderTarget(); + const GrPipeline& pipeline) { + const GrRenderTarget* rt = pipeline.getRenderTarget(); SkISize size; size.set(rt->width(), rt->height()); if (fRenderTargetState.fRenderTargetOrigin != rt->origin() || @@ -228,9 +228,9 @@ void GrGLNvprProgram::setTransformData(const GrPrimitiveProcessor& primProc, } void GrGLNvprProgram::onSetRenderTargetState(const GrPrimitiveProcessor& primProc, - const GrOptDrawState& optState) { + const GrPipeline& pipeline) { SkASSERT(!primProc.willUseGeoShader() && primProc.numAttribs() == 0); - const GrRenderTarget* rt = optState.getRenderTarget(); + const GrRenderTarget* rt = pipeline.getRenderTarget(); SkISize size; size.set(rt->width(), rt->height()); fGpu->glPathRendering()->setProjectionMatrix(primProc.viewMatrix(), diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h index cce6c2a4d3..e49fbabf86 100644 --- a/src/gpu/gl/GrGLProgram.h +++ b/src/gpu/gl/GrGLProgram.h @@ -10,7 +10,6 @@ #define GrGLProgram_DEFINED #include "builders/GrGLProgramBuilder.h" -#include "GrDrawState.h" #include "GrGLContext.h" #include "GrGLProgramDesc.h" #include "GrGLSL.h" @@ -23,6 +22,7 @@ class GrGLProcessor; class GrGLInstalledProcessors; class GrGLProgramBuilder; +class GrPipeline; /** * This class manages a GPU program and records per-program information. @@ -95,7 +95,7 @@ public: * GrGLGpu object to bind the textures required by the GrGLProcessors. The color and coverage * stages come from GrGLProgramDesc::Build(). */ - void setData(const GrPrimitiveProcessor&, const GrOptDrawState&, const GrBatchTracker&); + void setData(const GrPrimitiveProcessor&, const GrPipeline&, const GrBatchTracker&); protected: typedef GrGLProgramDataManager::UniformHandle UniformHandle; @@ -116,7 +116,7 @@ protected: void initSamplers(Proc*, int* texUnitIdx); // A templated helper to loop over effects, set the transforms(via subclass) and bind textures - void setFragmentData(const GrPrimitiveProcessor&, const GrOptDrawState&); + void setFragmentData(const GrPrimitiveProcessor&, const GrPipeline&); virtual void setTransformData(const GrPrimitiveProcessor&, const GrPendingFragmentStage&, int index, @@ -131,8 +131,8 @@ protected: virtual void didSetData() {} // Helper for setData() that sets the view matrix and loads the render target height uniform - void setRenderTargetState(const GrPrimitiveProcessor&, const GrOptDrawState&); - virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrOptDrawState&); + void setRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&); + virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&); // these reflect the current values of uniforms (GL uniform values travel with program) RenderTargetState fRenderTargetState; @@ -180,7 +180,7 @@ private: const GrPendingFragmentStage&, int index, GrGLInstalledFragProc*) SK_OVERRIDE; - virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrOptDrawState&); + virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&); friend class GrGLNvprProgramBuilder; diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp index a89941c884..32f831e84c 100644 --- a/src/gpu/gl/GrGLProgramDesc.cpp +++ b/src/gpu/gl/GrGLProgramDesc.cpp @@ -9,7 +9,7 @@ #include "GrGLProcessor.h" #include "GrProcessor.h" #include "GrGLGpu.h" -#include "GrOptDrawState.h" +#include "GrPipeline.h" #include "SkChecksum.h" #include "gl/builders/GrGLFragmentShaderBuilder.h" @@ -88,7 +88,7 @@ static bool get_meta_key(const GrProcessor& proc, bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, const GrPrimitiveProcessor& primProc, - const GrOptDrawState& optState, + const GrPipeline& pipeline, const GrProgramDesc::DescInfo& descInfo, const GrGLGpu* gpu, const GrBatchTracker& batchTracker) { @@ -110,8 +110,8 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, return false; } - for (int s = 0; s < optState.numFragmentStages(); ++s) { - const GrPendingFragmentStage& fps = optState.getFragmentStage(s); + for (int s = 0; s < pipeline.numFragmentStages(); ++s) { + const GrPendingFragmentStage& fps = pipeline.getFragmentStage(s); const GrFragmentProcessor& fp = *fps.processor(); fp.getGLProcessorKey(gpu->glCaps(), &b); if (!get_meta_key(fp, gpu->glCaps(), primProc.getTransformKey(fp.coordTransforms()), &b)) { @@ -120,7 +120,7 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, } } - const GrXferProcessor& xp = *optState.getXferProcessor(); + const GrXferProcessor& xp = *pipeline.getXferProcessor(); xp.getGLProcessorKey(gpu->glCaps(), &b); if (!get_meta_key(xp, gpu->glCaps(), 0, &b)) { desc->fKey.reset(); @@ -136,7 +136,7 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, memset(header, 0, kHeaderSize); if (descInfo.fReadsDst) { - const GrDeviceCoordTexture* dstCopy = optState.getDstCopy(); + const GrDeviceCoordTexture* dstCopy = pipeline.getDstCopy(); SkASSERT(dstCopy || gpu->caps()->dstReadInShaderSupport()); const GrTexture* dstCopyTexture = NULL; if (dstCopy) { @@ -151,14 +151,14 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc, if (descInfo.fReadsFragPosition) { header->fFragPosKey = - GrGLFragmentShaderBuilder::KeyForFragmentPosition(optState.getRenderTarget(), + GrGLFragmentShaderBuilder::KeyForFragmentPosition(pipeline.getRenderTarget(), gpu->glCaps()); } else { header->fFragPosKey = 0; } - header->fColorEffectCnt = optState.numColorStages(); - header->fCoverageEffectCnt = optState.numCoverageStages(); + header->fColorEffectCnt = pipeline.numColorStages(); + header->fCoverageEffectCnt = pipeline.numCoverageStages(); desc->finalize(); return true; } diff --git a/src/gpu/gl/GrGLProgramDesc.h b/src/gpu/gl/GrGLProgramDesc.h index 0584082a83..e4db4c3581 100644 --- a/src/gpu/gl/GrGLProgramDesc.h +++ b/src/gpu/gl/GrGLProgramDesc.h @@ -42,7 +42,7 @@ public: * Builds a GL specific program descriptor * * @param GrPrimitiveProcessor The geometry - * @param GrOptDrawState The optimized drawstate. The descriptor will represent a program + * @param GrPipeline The optimized drawstate. The descriptor will represent a program * which this optstate can use to draw with. The optstate contains * general draw information, as well as the specific color, geometry, * and coverage stages which will be used to generate the GL Program for @@ -57,7 +57,7 @@ public: **/ static bool Build(GrProgramDesc*, const GrPrimitiveProcessor&, - const GrOptDrawState&, + const GrPipeline&, const GrProgramDesc::DescInfo&, const GrGLGpu*, const GrBatchTracker&); diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp index 9fbb4c1953..088169622c 100644 --- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp +++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp @@ -193,8 +193,8 @@ void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr // First we loop over all of the installed processors and collect coord transforms. These will // be sent to the GrGLPrimitiveProcessor in its emitCode function SkSTArray<8, GrGLProcessor::TransformedCoordsArray> outCoords; - for (int i = 0; i < this->optState().numFragmentStages(); i++) { - const GrFragmentProcessor* processor = this->optState().getFragmentStage(i).processor(); + for (int i = 0; i < this->pipeline().numFragmentStages(); i++) { + const GrFragmentProcessor* processor = this->pipeline().getFragmentStage(i).processor(); SkSTArray<2, const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back(); for (int t = 0; t < processor->numTransforms(); t++) { procCoords.push_back(&processor->coordTransform(t)); @@ -205,10 +205,10 @@ void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr this->emitAndInstallProc(primProc, inputColor, inputCoverage); fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs)); - int numProcs = this->optState().numFragmentStages(); - this->emitAndInstallFragProcs(0, this->optState().numColorStages(), inputColor); - this->emitAndInstallFragProcs(this->optState().numColorStages(), numProcs, inputCoverage); - this->emitAndInstallXferProc(*this->optState().getXferProcessor(), *inputColor, *inputCoverage); + int numProcs = this->pipeline().numFragmentStages(); + this->emitAndInstallFragProcs(0, this->pipeline().numColorStages(), inputColor); + this->emitAndInstallFragProcs(this->pipeline().numColorStages(), numProcs, inputCoverage); + this->emitAndInstallXferProc(*this->pipeline().getXferProcessor(), *inputColor, *inputCoverage); } void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, @@ -216,7 +216,7 @@ void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, GrGLSLExpr4* inOut) { for (int e = procOffset; e < numProcs; ++e) { GrGLSLExpr4 output; - const GrPendingFragmentStage& stage = this->optState().getFragmentStage(e); + const GrPendingFragmentStage& stage = this->pipeline().getFragmentStage(e); this->emitAndInstallProc(stage, e, *inOut, &output); *inOut = output; } diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h index 612791e078..4b40cefad0 100644 --- a/src/gpu/gl/builders/GrGLProgramBuilder.h +++ b/src/gpu/gl/builders/GrGLProgramBuilder.h @@ -15,8 +15,8 @@ #include "../GrGLUniformHandle.h" #include "../GrGLGeometryProcessor.h" #include "../GrGLXferProcessor.h" -#include "../../GrOptDrawState.h" #include "../../GrPendingFragmentStage.h" +#include "../../GrPipeline.h" /* * This is the base class for a series of interfaces. This base class *MUST* remain abstract with @@ -283,7 +283,7 @@ protected: GrGLProgramBuilder(GrGLGpu*, const DrawArgs&); const GrPrimitiveProcessor& primitiveProcessor() const { return *fArgs.fPrimitiveProcessor; } - const GrOptDrawState& optState() const { return *fArgs.fOptState; } + const GrPipeline& pipeline() const { return *fArgs.fPipeline; } const GrProgramDesc& desc() const { return *fArgs.fDesc; } const GrBatchTracker& batchTracker() const { return *fArgs.fBatchTracker; } const GrProgramDesc::KeyHeader& header() const { return fArgs.fDesc->header(); } diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp index 638e229caf..c43d757230 100644 --- a/tests/GLProgramsTest.cpp +++ b/tests/GLProgramsTest.cpp @@ -14,7 +14,7 @@ #include "GrContextFactory.h" #include "GrInvariantOutput.h" -#include "GrOptDrawState.h" +#include "GrPipeline.h" #include "GrTest.h" #include "GrXferProcessor.h" #include "SkChecksum.h" @@ -121,12 +121,13 @@ static GrRenderTarget* random_render_target(GrContext* context, return SkRef(texture->asRenderTarget()); } -static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps, GrDrawState* ds, - SkRandom* random, GrTexture* dummyTextures[]) { +static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps, + GrPipelineBuilder* pipelineBuilder, SkRandom* random, + GrTexture* dummyTextures[]) { SkAutoTUnref<const GrXPFactory> xpf( GrProcessorTestFactory<GrXPFactory>::CreateStage(random, context, caps, dummyTextures)); SkASSERT(xpf); - ds->setXPFactory(xpf.get()); + pipelineBuilder->setXPFactory(xpf.get()); } static const GrGeometryProcessor* get_random_gp(GrContext* context, @@ -140,7 +141,7 @@ static const GrGeometryProcessor* get_random_gp(GrContext* context, } static void set_random_color_coverage_stages(GrGLGpu* gpu, - GrDrawState* ds, + GrPipelineBuilder* pipelineBuilder, int maxStages, bool usePathRendering, SkRandom* random, @@ -171,24 +172,24 @@ static void set_random_color_coverage_stages(GrGLGpu* gpu, // finally add the stage to the correct pipeline in the drawstate if (s < numColorProcs) { - ds->addColorProcessor(fp); + pipelineBuilder->addColorProcessor(fp); } else { - ds->addCoverageProcessor(fp); + pipelineBuilder->addCoverageProcessor(fp); } ++s; } } -static void set_random_state(GrDrawState* ds, SkRandom* random) { +static void set_random_state(GrPipelineBuilder* pipelineBuilder, SkRandom* random) { int state = 0; - for (int i = 1; i <= GrDrawState::kLast_StateBit; i <<= 1) { + for (int i = 1; i <= GrPipelineBuilder::kLast_StateBit; i <<= 1) { state |= random->nextBool() * i; } - ds->enableState(state); + pipelineBuilder->enableState(state); } // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()' -static void set_random_stencil(GrDrawState* ds, SkRandom* random) { +static void set_random_stencil(GrPipelineBuilder* pipelineBuilder, SkRandom* random) { GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil, kReplace_StencilOp, kReplace_StencilOp, @@ -205,9 +206,9 @@ static void set_random_stencil(GrDrawState* ds, SkRandom* random) { 0xffff); if (random->nextBool()) { - ds->setStencil(kDoesWriteStencil); + pipelineBuilder->setStencil(kDoesWriteStencil); } else { - ds->setStencil(kDoesNotWriteStencil); + pipelineBuilder->setStencil(kDoesNotWriteStencil); } } @@ -266,8 +267,8 @@ bool GrDrawTarget::programUnitTest(int maxStages) { return false; } - GrDrawState ds; - ds.setRenderTarget(rt.get()); + GrPipelineBuilder pipelineBuilder; + pipelineBuilder.setRenderTarget(rt.get()); // if path rendering we have to setup a couple of things like the draw type bool usePathRendering = gpu->glCaps().pathRenderingSupport() && random.nextBool(); @@ -282,17 +283,17 @@ bool GrDrawTarget::programUnitTest(int maxStages) { pathProc.reset(GrPathProcessor::Create(GrColor_WHITE)); } set_random_color_coverage_stages(gpu, - &ds, + &pipelineBuilder, maxStages - hasGeometryProcessor, usePathRendering, &random, dummyTextures); // creates a random xfer processor factory on the draw state - set_random_xpf(fContext, gpu->glCaps(), &ds, &random, dummyTextures); + set_random_xpf(fContext, gpu->glCaps(), &pipelineBuilder, &random, dummyTextures); - set_random_state(&ds, &random); - set_random_stencil(&ds, &random); + set_random_state(&pipelineBuilder, &random); + set_random_stencil(&pipelineBuilder, &random); GrDeviceCoordTexture dstCopy; @@ -302,24 +303,24 @@ bool GrDrawTarget::programUnitTest(int maxStages) { } else { primProc = pathProc.get(); } - if (!this->setupDstReadIfNecessary(&ds, &dstCopy, NULL)) { + if (!this->setupDstReadIfNecessary(&pipelineBuilder, &dstCopy, NULL)) { SkDebugf("Couldn't setup dst read texture"); return false; } // create optimized draw state, setup readDst texture if required, and build a descriptor // and program. ODS creation can fail, so we have to check - GrOptDrawState ods(ds, primProc, *gpu->caps(), scissor, &dstCopy); - if (ods.mustSkip()) { + GrPipeline pipeline(pipelineBuilder, primProc, *gpu->caps(), scissor, &dstCopy); + if (pipeline.mustSkip()) { continue; } GrBatchTracker bt; - primProc->initBatchTracker(&bt, ods.getInitBatchTracker()); + primProc->initBatchTracker(&bt, pipeline.getInitBatchTracker()); GrProgramDesc desc; - gpu->buildProgramDesc(&desc, *primProc, ods, ods.descInfo(), bt); + gpu->buildProgramDesc(&desc, *primProc, pipeline, pipeline.descInfo(), bt); - GrGpu::DrawArgs args(primProc, &ods, &desc, &bt); + GrGpu::DrawArgs args(primProc, &pipeline, &desc, &bt); SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(args, gpu)); if (NULL == program.get()) { |