Remove GrClipTarget

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 16 matching lines @@
 #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()))
     , fResourceProvider(resourceProvider)
     , fFlushing(false)
     , fLastFlushToken(0) {
+    // TODO: Stop extracting the context (currently needed by GrClipMaskManager)
+    fContext = fGpu->getContext();
 }
 
 GrDrawTarget::~GrDrawTarget() {
     fGpu->unref();
-    fCaps->unref();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
                                            const GrProcOptInfo& colorPOI,
                                            const GrProcOptInfo& coveragePOI,
                                            GrXferProcessor::DstTexture* dstTexture,
                                            const SkRect& batchBounds) {
     SkRect bounds = batchBounds;
@@ skipping 15 matching lines @@
         }
     }
 
     SkIRect copyRect;
     pipelineBuilder.clip().getConservativeBounds(rt, &copyRect);
 
     SkIRect drawIBounds;
     bounds.roundOut(&drawIBounds);
     if (!copyRect.intersect(drawIBounds)) {
 #ifdef SK_DEBUG
-        GrCapsDebugf(fCaps, "Missed an early reject. "
-                        "Bailing on draw from setupDstReadIfNecessary.\n");
+        GrCapsDebugf(this->caps(), "Missed an early reject. "
+                                   "Bailing on draw from setupDstReadIfNecessary.\n");
 #endif
         return false;
     }
 
     // MSAA consideration: When there is support for reading MSAA samples in the shader we could
     // have per-sample dst values by making the copy multisampled.
     GrSurfaceDesc desc;
-    if (!this->getGpu()->initCopySurfaceDstDesc(rt, &desc)) {
+    if (!fGpu->initCopySurfaceDstDesc(rt, &desc)) {
         desc.fOrigin = kDefault_GrSurfaceOrigin;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fConfig = rt->config();
     }
 
     desc.fWidth = copyRect.width();
     desc.fHeight = copyRect.height();
 
     static const uint32_t kFlags = 0;
     SkAutoTUnref<GrTexture> copy(fResourceProvider->createApproxTexture(desc, kFlags));
@@ skipping 38 matching lines @@
 
 void GrDrawTarget::reset() {
     fBatches.reset();
 }
 
 void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder, GrDrawBatch* batch) {
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     GrPipelineBuilder::AutoRestoreStencil ars;
-    if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &batch->bounds())) {
+    if (!fClipMaskManager->setupClipping(pipelineBuilder, &arfps, &ars, &scissorState,
+                                         &batch->bounds())) {
         return;
     }
 
     GrPipeline::CreateArgs args;
     if (!this->installPipelineInDrawBatch(&pipelineBuilder, &scissorState, batch)) {
         return;
     }
 
     this->recordBatch(batch);
 }
@@ skipping 23 matching lines @@
     switch (fill) {
         default:
             SkFAIL("Unexpected path fill.");
         case GrPathRendering::kWinding_FillType:
             *outStencilSettings = winding_path_stencil_settings();
             break;
         case GrPathRendering::kEvenOdd_FillType:
             *outStencilSettings = even_odd_path_stencil_settings();
             break;
     }
-    this->clipMaskManager()->adjustPathStencilParams(sb, outStencilSettings);
+    fClipMaskManager->adjustPathStencilParams(sb, outStencilSettings);
 }
 
 void GrDrawTarget::stencilPath(const GrPipelineBuilder& pipelineBuilder,
                                const SkMatrix& viewMatrix,
                                const GrPath* path,
                                GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport());
 
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     GrPipelineBuilder::AutoRestoreStencil ars;
-    if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, nullptr)) {
+
+    if (!fClipMaskManager->setupClipping(pipelineBuilder, &arfps, &ars, &scissorState, nullptr)) {
         return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
 
     GrBatch* batch = GrStencilPathBatch::Create(viewMatrix,
@@ skipping 26 matching lines @@
                                       GrPathRendering::FillType fill) {
     GrDrawPathBatchBase* batch = GrDrawPathRangeBatch::Create(viewMatrix, localMatrix, color, draw);
     this->drawPathBatch(pipelineBuilder, batch, fill);
     batch->unref();
 }
 
 void GrDrawTarget::drawPathBatch(const GrPipelineBuilder& pipelineBuilder,
                                  GrDrawPathBatchBase* batch,
                                  GrPathRendering::FillType fill) {
     // 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.
+    // after setting up clipping 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, &batch->bounds())) {
+    if (!fClipMaskManager->setupClipping(pipelineBuilder, &arfps, &ars, &scissorState,
+                                         &batch->bounds())) {
         return;
     }
 
     // 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);
 
@@ skipping 56 matching lines @@
         rect->contains(rtRect)) {
         rect = &rtRect;
     } else {
         clippedRect = *rect;
         if (!clippedRect.intersect(rtRect)) {
             return;
         }
         rect = &clippedRect;
     }
 
-    if (fCaps->useDrawInsteadOfClear()) {
+    if (this->caps()->useDrawInsteadOfClear()) {
         // This works around a driver bug with clear by drawing a rect instead.
         // The driver will ignore a clear if it is the only thing rendered to a
         // target before the target is read.
         if (rect == &rtRect) {
             this->discard(renderTarget);
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setRenderTarget(renderTarget);
 
@@ skipping 99 matching lines @@
         return false;
     }
 
     if (!batch->installPipeline(args)) {
         return false;
     }
 
     return true;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-GrClipTarget::GrClipTarget(GrContext* context)
-    : INHERITED(context->getGpu(), context->resourceProvider())
-    , fContext(context) {
-    fClipMaskManager.reset(new 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();
-};
-
-void GrClipTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
+void GrDrawTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = new GrClearStencilClipBatch(rect, insideClip, rt);
     this->recordBatch(batch);
     batch->unref();
 }