Put drawPath in GrBatch.

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"
 
 #include "GrCaps.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrPipeline.h"
 #include "GrMemoryPool.h"
 #include "GrRenderTarget.h"
 #include "GrResourceProvider.h"
 #include "GrRenderTargetPriv.h"
 #include "GrSurfacePriv.h"
 #include "GrTexture.h"
 #include "GrVertexBuffer.h"
 
 #include "batches/GrClearBatch.h"
 #include "batches/GrCopySurfaceBatch.h"
 #include "batches/GrDiscardBatch.h"
 #include "batches/GrDrawBatch.h"
+#include "batches/GrDrawPathBatch.h"
 #include "batches/GrRectBatchFactory.h"
 #include "batches/GrStencilPathBatch.h"
 
 #include "SkStrokeRec.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::GrDrawTarget(GrGpu* gpu, GrResourceProvider* resourceProvider)
     : fGpu(SkRef(gpu))
     , fCaps(SkRef(gpu->caps()))
@@ skipping 86 matching lines @@
 
     this->onFlush();
 
     this->getGpu()->restoreActiveTraceMarkers();
 
     fFlushing = false;
     this->reset();
 }
 
 void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder, GrDrawBatch* batch) {
-    // TODO some kind of checkdraw, but not at this level
-
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     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,
                                             this);
+
     if (!pipelineInfo.valid()) {
         return;
     }
     if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
         return;
     }
     this->onDrawBatch(batch);
 }
 
 static const GrStencilSettings& winding_path_stencil_settings() {
@@ skipping 59 matching lines @@
                                                 pipelineBuilder.getRenderTarget(),
                                                 path);
     this->onDrawBatch(batch);
     batch->unref();
 }
 
 void GrDrawTarget::drawPath(const 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()->shaderCaps()->pathRenderingSupport());
 
-    SkRect devBounds = path->getBounds();
-    pathProc->viewMatrix().mapRect(&devBounds);
+    GrDrawPathBatch* batch = GrDrawPathBatch::Create(pathProc, path);
 
-    // Setup clip
+    // This looks like drawBatch() but there is an added wrinkle that stencil settings get inserted
+    // after setupClip() but before onDrawBatch(). TODO: Figure out a better model for handling
+    // stencil settings WRT interactions between pipeline(builder), clipmaskmanager, and batches.
+
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     GrPipelineBuilder::AutoRestoreStencil ars;
-    if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &devBounds)) {
-       return;
+    if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &batch->bounds())) {
+        return;
     }
 
-    // set stencil settings for path
+    // Ensure the render target has a stencil buffer and get the stencil settings.
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
+    batch->setStencilSettings(stencilSettings);
 
-    GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, pathProc, &devBounds,
-                                            this);
+    // 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, batch, NULL, this);
+
     if (!pipelineInfo.valid()) {
         return;
     }
+    if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
+        return;
+    }
 
-    this->onDrawPath(pathProc, path, stencilSettings, pipelineInfo);
+    this->onDrawBatch(batch);
+    batch->unref();
 }
 
 void GrDrawTarget::drawPaths(const GrPipelineBuilder& pipelineBuilder,
                              const GrPathProcessor* pathProc,
                              const GrPathRange* pathRange,
                              const void* indices,
                              PathIndexType indexType,
                              const float transformValues[],
                              PathTransformType transformType,
                              int count,
@@ skipping 208 matching lines @@
     // The clip mask manager can rebuild all its clip masks so just
     // get rid of them all.
     fClipMaskManager->purgeResources();
 };
 
 void GrClipTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = SkNEW_ARGS(GrClearStencilClipBatch, (rect, insideClip, rt));
     this->onDrawBatch(batch);
     batch->unref();
 }