Remove GrFlushToGpuDrawTarget and move functionality up to GrDrawTarget.

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 "GrBatch.h"
+#include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrPath.h"
 #include "GrPipeline.h"
 #include "GrMemoryPool.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrSurfacePriv.h"
 #include "GrTemplates.h"
 #include "GrTexture.h"
@@ skipping 26 matching lines @@
     this->setIndexBuffer(di.indexBuffer());
 
     return *this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER 0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
-GrDrawTarget::GrDrawTarget(GrContext* context)
+GrDrawTarget::GrDrawTarget(GrContext* context,
+                           GrVertexBufferAllocPool* vpool,
+                           GrIndexBufferAllocPool* ipool)
     : fContext(context)
-    , fGpuTraceMarkerCount(0) {
+    , fCaps(SkRef(context->getGpu()->caps()))
+    , fGpuTraceMarkerCount(0)
+    , fVertexPool(vpool)
+    , fIndexPool(ipool)
+    , fFlushing(false) {
     SkASSERT(context);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
                                            const GrProcOptInfo& colorPOI,
                                            const GrProcOptInfo& coveragePOI,
                                            GrDeviceCoordTexture* dstCopy,
                                            const SkRect* drawBounds) {
@@ skipping 15 matching lines @@
         }
     } else {
 #ifdef SK_DEBUG
         //SkDebugf("No dev bounds when dst copy is made.\n");
 #endif
     }
 
     // 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;
-    this->initCopySurfaceDstDesc(rt, &desc);
+    if (!this->getGpu()->initCopySurfaceDstDesc(rt, &desc)) {
+        desc.fOrigin = kDefault_GrSurfaceOrigin;
+        desc.fFlags = kRenderTarget_GrSurfaceFlag;
+        desc.fConfig = rt->config();
+    }
+
+
     desc.fWidth = copyRect.width();
     desc.fHeight = copyRect.height();
 
     SkAutoTUnref<GrTexture> copy(
         fContext->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
 
     if (!copy) {
         SkDebugf("Failed to create temporary copy of destination texture.\n");
         return false;
     }
     SkIPoint dstPoint = {0, 0};
     if (this->copySurface(copy, rt, copyRect, dstPoint)) {
         dstCopy->setTexture(copy);
         dstCopy->setOffset(copyRect.fLeft, copyRect.fTop);
         return true;
     } else {
         return false;
     }
 }
 
+void GrDrawTarget::reset() {
+    fVertexPool->reset();
+    fIndexPool->reset();
+
+    this->onReset();
+}
+
+void GrDrawTarget::flush() {
+    if (fFlushing) {
+        return;
+    }
+    fFlushing = true;
+
+    this->getGpu()->saveActiveTraceMarkers();
+
+    this->onFlush();
+
+    this->getGpu()->restoreActiveTraceMarkers();
+
+    fFlushing = false;
+    this->reset();
+}
+
 void GrDrawTarget::drawBatch(GrPipelineBuilder* pipelineBuilder,
                              GrBatch* batch,
                              const SkRect* devBounds) {
     SkASSERT(pipelineBuilder);
     // TODO some kind of checkdraw, but not at this level
 
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessors arfp;
     GrPipelineBuilder::AutoRestoreStencil ars;
@@ skipping 279 matching lines @@
     // If the rect is outside the src or dst then we've already succeeded.
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         return true;
     }
 
-    if (this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint)) {
+    if (this->getGpu()->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint)) {
+        this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
         return true;
     }
 
     GrRenderTarget* rt = dst->asRenderTarget();
     GrTexture* tex = src->asTexture();
 
     if ((dst == src) || !rt || !tex) {
         return false;
     }
 
@@ skipping 23 matching lines @@
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we're guaranteed success
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         return true;
     }
-    return this->internalCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
-}
-
-bool GrDrawTarget::internalCanCopySurface(const GrSurface* dst,
-                                          const GrSurface* src,
-                                          const SkIRect& clippedSrcRect,
-                                          const SkIPoint& clippedDstPoint) {
-    // Check that the read/write rects are contained within the src/dst bounds.
-    SkASSERT(!clippedSrcRect.isEmpty());
-    SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(clippedSrcRect));
-    SkASSERT(clippedDstPoint.fX >= 0 && clippedDstPoint.fY >= 0);
-    SkASSERT(clippedDstPoint.fX + clippedSrcRect.width() <= dst->width() &&
-             clippedDstPoint.fY + clippedSrcRect.height() <= dst->height());
-
-    // The base class can do it as a draw or the subclass may be able to handle it.
     return ((dst != src) && dst->asRenderTarget() && src->asTexture()) ||
-           this->onCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
+           this->getGpu()->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
 }
 
 void GrDrawTarget::setupPipeline(const PipelineInfo& pipelineInfo,
                                  GrPipeline* pipeline) {
     SkNEW_PLACEMENT_ARGS(pipeline, GrPipeline, (*pipelineInfo.fPipelineBuilder,
                                                 pipelineInfo.fColorPOI,
                                                 pipelineInfo.fCoveragePOI,
                                                 *this->caps(),
                                                 *pipelineInfo.fScissor,
                                                 &pipelineInfo.fDstCopy));
@@ skipping 247 matching lines @@
                              GrPipelineBuilder::AutoRestoreFragmentProcessors* arfp,
                              GrPipelineBuilder::AutoRestoreStencil* ars,
                              GrScissorState* scissorState,
                              const SkRect* devBounds) {
     return fClipMaskManager.setupClipping(pipelineBuilder,
                                           arfp,
                                           ars,
                                           scissorState,
                                           devBounds);
 }