Trim the copy of the dst made for dst-reading effects using the clip and dev-bounds of draw.

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.
  */
 
 
 
@@ skipping 389 matching lines @@
 
     GrAssert(drawState.validateVertexAttribs());
 #endif
     if (NULL == drawState.getRenderTarget()) {
         return false;
     }
     return true;
 }
 
 bool GrDrawTarget::setupDstReadIfNecessary(DrawInfo* info) {
-    bool willReadDst = false;
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        const GrEffectRef* effect = this->drawState()->getStage(s).getEffect();
-        if (NULL != effect && (*effect)->willReadDst()) {
-            willReadDst = true;
-            break;
-        }
-    }
-    if (!willReadDst) {
+    if (!this->getDrawState().willEffectReadDst()) {
         return true;
     }
     GrRenderTarget* rt = this->drawState()->getRenderTarget();
     // If the dst is not a texture then we don't currently have a way of copying the
     // texture. TODO: make copying RT->Tex (or Surface->Surface) a GrDrawTarget operation that can
     // be built on top of GL/D3D APIs.
     if (NULL == rt->asTexture()) {
         GrPrintf("Reading Dst of non-texture render target is not currently supported.\n");
         return false;
     }
-    // TODO: Consider bounds of draw and bounds of clip
 
+    const GrClipData* clip = this->getClip();
+    GrIRect copyRect;
+    clip->getConservativeBounds(this->getDrawState().getRenderTarget(), &copyRect);
+    SkIRect drawIBounds;
+    if (info->getDevIBounds(&drawIBounds)) {
+        if (!copyRect.intersect(drawIBounds)) {
+#if GR_DEBUG
+            GrPrintf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
+#endif
+            return false;
+        }
+    } else {
+#if GR_DEBUG
+        //GrPrintf("No dev bounds when dst copy is made.\n");
+#endif
+    }
+    
     GrDrawTarget::AutoGeometryAndStatePush agasp(this, kReset_ASRInit);
 
     // The draw will resolve dst if it has MSAA. Two things to consider in the future:
     // 1) to make the dst values be pre-resolve we'd need to be able to copy to MSAA
     // texture and sample it correctly in the shader. 2) If 1 isn't available then we
     // should just resolve and use the resolved texture directly rather than making a
     // copy of it.
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
-    desc.fWidth = rt->width();
-    desc.fHeight = rt->height();
+    desc.fWidth = copyRect.width();
+    desc.fHeight = copyRect.height();
     desc.fSampleCnt = 0;
     desc.fConfig = rt->config();
 
     GrAutoScratchTexture ast(fContext, desc, GrContext::kApprox_ScratchTexMatch);
 
     if (NULL == ast.texture()) {
         GrPrintf("Failed to create temporary copy of destination texture.\n");
         return false;
     }
     this->drawState()->disableState(GrDrawState::kClip_StateBit);
     this->drawState()->setRenderTarget(ast.texture()->asRenderTarget());
     static const int kTextureStage = 0;
     SkMatrix matrix;
     matrix.setIDiv(rt->width(), rt->height());
     this->drawState()->createTextureEffect(kTextureStage, rt->asTexture(), matrix);
-    SkRect copyRect = SkRect::MakeWH(SkIntToScalar(desc.fWidth),
-                                     SkIntToScalar(desc.fHeight));
-    this->drawRect(copyRect, NULL, &copyRect, NULL);
+    
+    SkRect srcRect = SkRect::MakeFromIRect(copyRect);
+    SkRect dstRect = SkRect::MakeWH(SkIntToScalar(copyRect.width()),
+                                    SkIntToScalar(copyRect.height()));
+    this->drawRect(dstRect, NULL, &srcRect, NULL);
+    
     info->fDstCopy.setTexture(ast.texture());
-    info->fDstCopy.setOffset(0, 0);
+    info->fDstCopy.setOffset(copyRect.fLeft, copyRect.fTop);
     return true;
 }
 
 void GrDrawTarget::drawIndexed(GrPrimitiveType type,
                                int startVertex,
                                int startIndex,
                                int vertexCount,
                                int indexCount,
                                const SkRect* devBounds) {
     if (indexCount > 0 && this->checkDraw(type, startVertex, startIndex, vertexCount, indexCount)) {
@@ skipping 166 matching lines @@
         GrAssert(attribCount == 2);
         GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(geo.vertices()) +
                                             kAttribs[1].fOffset);
         coords->setRectFan(localRect->fLeft, localRect->fTop,
                            localRect->fRight, localRect->fBottom,
                            vsize);
         if (NULL != localMatrix) {
             localMatrix->mapPointsWithStride(coords, vsize, 4);
         }
     }
+    SkTLazy<SkRect> bounds;
+    if (this->getDrawState().willEffectReadDst()) {
+        bounds.init();
+        this->getDrawState().getViewMatrix().mapRect(bounds.get(), rect);
+    }
 
-    this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
+    this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4, bounds.getMaybeNull());
 }
 
 void GrDrawTarget::clipWillBeSet(const GrClipData* clipData) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::AutoStateRestore::AutoStateRestore() {
     fDrawTarget = NULL;
 }
@@ skipping 139 matching lines @@
     GrPrintf("HW AA Lines Support         : %s\n", gNY[fHWAALineSupport]);
     GrPrintf("Shader Derivative Support   : %s\n", gNY[fShaderDerivativeSupport]);
     GrPrintf("Geometry Shader Support     : %s\n", gNY[fGeometryShaderSupport]);
     GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
     GrPrintf("Buffer Lock Support         : %s\n", gNY[fBufferLockSupport]);
     GrPrintf("Path Stenciling Support     : %s\n", gNY[fPathStencilingSupport]);
     GrPrintf("Max Texture Size            : %d\n", fMaxTextureSize);
     GrPrintf("Max Render Target Size      : %d\n", fMaxRenderTargetSize);
     GrPrintf("Max Sample Count            : %d\n", fMaxSampleCount);
 }