GrBatchPrototype

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 "GrDrawTarget.h"
+#include "GrBatch.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrPath.h"
 #include "GrRenderTarget.h"
 #include "GrSurfacePriv.h"
 #include "GrTemplates.h"
 #include "GrTexture.h"
 #include "GrVertexBuffer.h"
 
 #include "SkStrokeRec.h"
@@ skipping 404 matching lines @@
     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;
     }
 }
 
+// TODO disgusting hack
+bool GrDrawTarget::setupDstReadIfNecessary(GrDrawState* ds,
+                                           const GrBatch* batch,
+                                           GrDeviceCoordTexture* dstCopy,
+                                           const SkRect* drawBounds) {
+    if (this->caps()->dstReadInShaderSupport() || !ds->willEffectReadDstColor(batch)) {
+        return true;
+    }
+    SkIRect copyRect;
+    const GrClipData* clip = this->getClip();
+    GrRenderTarget* rt = ds->getRenderTarget();
+    clip->getConservativeBounds(rt, &copyRect);
+
+    if (drawBounds) {
+        SkIRect drawIBounds;
+        drawBounds->roundOut(&drawIBounds);
+        if (!copyRect.intersect(drawIBounds)) {
+#ifdef SK_DEBUG
+            SkDebugf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
+#endif
+            return false;
+        }
+    } 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);
+    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::drawIndexed(GrDrawState* ds,
                                const GrGeometryProcessor* gp,
                                GrPrimitiveType type,
                                int startVertex,
                                int startIndex,
                                int vertexCount,
                                int indexCount,
                                const SkRect* devBounds) {
     SkASSERT(ds);
     if (indexCount > 0 &&
@@ skipping 70 matching lines @@
         if (!this->setupDstReadIfNecessary(ds, gp, &dstCopy, devBounds)) {
             return;
         }
 
         this->setDrawBuffers(&info, gp->getVertexStride());
 
         this->onDraw(*ds, gp, info, scissorState, dstCopy.texture() ? &dstCopy : NULL);
     }
 }
 
+
+void GrDrawTarget::batchDraw(GrDrawState* ds,
+                             GrBatch* batch,
+                             GrPrimitiveType type,
+                             const SkRect* devBounds) {
+    SkASSERT(ds);
+    // TODO some kind of checkdraw, but not at this level
+
+    // Setup clip
+    GrScissorState scissorState;
+    GrDrawState::AutoRestoreEffects are;
+    GrDrawState::AutoRestoreStencil ars;
+    if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) {
+        return;
+    }
+
+    // TODO: We should continue with incorrect blending.

[bsalomon, 2015/01/20 16:14:02]

let's just remove the todo... we will probably never do such a thing.

+    GrDeviceCoordTexture dstCopy;
+    if (!this->setupDstReadIfNecessary(ds, batch, &dstCopy, devBounds)) {
+        return;
+    }
+
+    this->onBatchDraw(batch, *ds, type, scissorState, dstCopy.texture() ? &dstCopy : NULL);
+}
+
 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);
 }
 
 static const GrStencilSettings& even_odd_path_stencil_settings() {
@@ skipping 680 matching lines @@
                              GrDrawState::AutoRestoreStencil* ars,
                              GrScissorState* scissorState,
                              const SkRect* devBounds) {
     return fClipMaskManager.setupClipping(ds,
                                           are,
                                           ars,
                                           scissorState,
                                           this->getClip(),
                                           devBounds);
 }