Make GrBatch carry its own GrPipeline

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawTarget.h"
 
@@ skipping 123 matching lines @@
     GrPipelineBuilder::AutoRestoreStencil ars;
     if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &batch->bounds())) {
         return;
     }
 
     // Batch bounds are tight, so for dev copies
     // TODO move this into setupDstReadIfNecessary when paths are in batch
     SkRect bounds = batch->bounds();
     bounds.outset(0.5f, 0.5f);
 
-    GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, batch, &bounds,
+    GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, batch, &bounds,
                                             this);
-    if (pipelineInfo.mustSkipDraw()) {
+    if (!pipelineInfo.valid()) {
         return;
     }
-
-    this->onDrawBatch(batch, pipelineInfo);
+    if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
+        return;
+    }
+    this->onDrawBatch(batch);
 }
 
 static const GrStencilSettings& winding_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kIncClamp_StencilOp,
         kIncClamp_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0xFFFF, 0xFFFF, 0xFFFF);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
@@ skipping 67 matching lines @@
     if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &devBounds)) {
        return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
 
-    GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, pathProc, &devBounds,
+    GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, pathProc, &devBounds,
                                             this);
-    if (pipelineInfo.mustSkipDraw()) {
+    if (!pipelineInfo.valid()) {
         return;
     }
 
     this->onDrawPath(pathProc, path, stencilSettings, pipelineInfo);
 }
 
 void GrDrawTarget::drawPaths(const GrPipelineBuilder& pipelineBuilder,
                              const GrPathProcessor* pathProc,
                              const GrPathRange* pathRange,
                              const void* indices,
@@ skipping 20 matching lines @@
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
 
     // Don't compute a bounding box for dst copy texture, we'll opt
     // instead for it to just copy the entire dst. Realistically this is a moot
     // point, because any context that supports NV_path_rendering will also
     // support NV_blend_equation_advanced.
-    GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, pathProc, NULL, this);
-    if (pipelineInfo.mustSkipDraw()) {
+    GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, pathProc, NULL, this);
+    if (!pipelineInfo.valid()) {
         return;
     }
 
     this->onDrawPaths(pathProc, pathRange, indices, indexType, transformValues,
                       transformType, count, stencilSettings, pipelineInfo);
 }
 
 void GrDrawTarget::drawBWRect(const GrPipelineBuilder& pipelineBuilder,
                               GrColor color,
                               const SkMatrix& viewMatrix,
@@ skipping 158 matching lines @@
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         return;
     }
 
     this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
 }
 
-const GrPipeline* GrDrawTarget::setupPipeline(const PipelineInfo& pipelineInfo,
-                                              void* pipelineAddr,
-                                              GrPipelineOptimizations* optimizations) {
-    return GrPipeline::CreateAt(pipelineAddr, *pipelineInfo.fPipelineBuilder,
-                                              pipelineInfo.fColorPOI,
-                                              pipelineInfo.fCoveragePOI,
-                                              *this->caps(),
-                                              *pipelineInfo.fScissor,
-                                              &pipelineInfo.fDstTexture,
-                                              optimizations);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
-GrDrawTarget::PipelineInfo::PipelineInfo(const GrPipelineBuilder& pipelineBuilder,
-                                         GrScissorState* scissor,
+GrDrawTarget::PipelineInfo::PipelineInfo(const GrPipelineBuilder* pipelineBuilder,
+                                         const GrScissorState* scissor,
                                          const GrPrimitiveProcessor* primProc,
                                          const SkRect* devBounds,
-                                         GrDrawTarget* target)
-    : fPipelineBuilder(&pipelineBuilder)
-    , fScissor(scissor) {
-    fColorPOI = fPipelineBuilder->colorProcInfo(primProc);
-    fCoveragePOI = fPipelineBuilder->coverageProcInfo(primProc);
-    if (!target->setupDstReadIfNecessary(*fPipelineBuilder, fColorPOI, fCoveragePOI,
-                                         &fDstTexture, devBounds)) {
-        fPipelineBuilder = NULL;
+                                         GrDrawTarget* target) {
+    fArgs.fPipelineBuilder = pipelineBuilder;
+    fArgs.fCaps = target->caps();
+    fArgs.fScissor = scissor;
+    fArgs.fColorPOI = fArgs.fPipelineBuilder->colorProcInfo(primProc);
+    fArgs.fCoveragePOI = fArgs.fPipelineBuilder->coverageProcInfo(primProc);
+    if (!target->setupDstReadIfNecessary(*fArgs.fPipelineBuilder, fArgs.fColorPOI,
+                                         fArgs.fCoveragePOI, &fArgs.fDstTexture, devBounds)) {
+        fArgs.fPipelineBuilder = NULL;
     }
 }
 
-GrDrawTarget::PipelineInfo::PipelineInfo(const GrPipelineBuilder& pipelineBuilder,
-                                         GrScissorState* scissor,
+GrDrawTarget::PipelineInfo::PipelineInfo(const GrPipelineBuilder* pipelineBuilder,
+                                         const GrScissorState* scissor,
                                          const GrBatch* batch,
                                          const SkRect* devBounds,
-                                         GrDrawTarget* target)
-    : fPipelineBuilder(&pipelineBuilder)
-    , fScissor(scissor) {
-    fColorPOI = fPipelineBuilder->colorProcInfo(batch);
-    fCoveragePOI = fPipelineBuilder->coverageProcInfo(batch);
-    if (!target->setupDstReadIfNecessary(*fPipelineBuilder, fColorPOI, fCoveragePOI,
-                                         &fDstTexture, devBounds)) {
-        fPipelineBuilder = NULL;
+                                         GrDrawTarget* target) {
+    fArgs.fPipelineBuilder = pipelineBuilder;
+    fArgs.fCaps = target->caps();
+    fArgs.fScissor = scissor;
+    fArgs.fColorPOI = fArgs.fPipelineBuilder->colorProcInfo(batch);
+    fArgs.fCoveragePOI = fArgs.fPipelineBuilder->coverageProcInfo(batch);
+    if (!target->setupDstReadIfNecessary(*fArgs.fPipelineBuilder, fArgs.fColorPOI,
+                                         fArgs.fCoveragePOI, &fArgs.fDstTexture, devBounds)) {
+        fArgs.fPipelineBuilder = NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 GrClipTarget::GrClipTarget(GrContext* context)
     : INHERITED(context->getGpu(), context->resourceProvider())
     , fContext(context) {
     fClipMaskManager.reset(SkNEW_ARGS(GrClipMaskManager, (this)));
 }
 
 
 bool GrClipTarget::setupClip(const GrPipelineBuilder& pipelineBuilder,
                              GrPipelineBuilder::AutoRestoreFragmentProcessorState* arfps,
                              GrPipelineBuilder::AutoRestoreStencil* ars,
                              GrScissorState* scissorState,
                              const SkRect* devBounds) {
     return fClipMaskManager->setupClipping(pipelineBuilder,
                                            arfps,
                                            ars,
                                            scissorState,
                                            devBounds);
 }
 
 void GrClipTarget::purgeResources() {
     // The clip mask manager can rebuild all its clip masks so just
     // get rid of them all.
     fClipMaskManager->purgeResources();
 };