Add GrDrawTarget::copySurface.

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 394 matching lines @@
     }
     return true;
 }
 
 bool GrDrawTarget::setupDstReadIfNecessary(DrawInfo* info) {
     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.
+    // texture. TODO: API-specific impl of onCopySurface that can handle more cases.
     if (NULL == rt->asTexture()) {
         GrPrintf("Reading Dst of non-texture render target is not currently supported.\n");
         return false;
     }
 
     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 = 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 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(copyRect.fLeft, copyRect.fTop);
-    return true;
+    SkIPoint dstPoint = {0, 0};
+    if (this->copySurface(ast.texture(), rt, copyRect, dstPoint)) {
+        info->fDstCopy.setTexture(ast.texture());
+        info->fDstCopy.setOffset(copyRect.fLeft, copyRect.fTop);
+        return true;
+    } else {
+        return false;
+    }
 }
 
 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)) {
         DrawInfo info;
@@ skipping 270 matching lines @@
 
 GrDrawTarget::AutoClipRestore::AutoClipRestore(GrDrawTarget* target, const SkIRect& newClip) {
     fTarget = target;
     fClip = fTarget->getClip();
     fStack.init();
     fStack.get()->clipDevRect(newClip, SkRegion::kReplace_Op);
     fReplacementClip.fClipStack = fStack.get();
     target->setClip(&fReplacementClip);
 }
 
+bool GrDrawTarget::copySurface(GrSurface* dst,
+                               GrSurface* src,
+                               const SkIRect& srcRect,
+                               const SkIPoint& dstPoint) {
+    SkIRect clippedSrcRect(srcRect);
+    SkIPoint clippedDstPoint(dstPoint);
+    
+    // clip the left edge to src and dst bounds, adjusting dstPoint if neceessary
+    if (clippedSrcRect.fLeft < 0) {
+        clippedDstPoint.fX -= clippedSrcRect.fLeft;
+        clippedSrcRect.fLeft = 0;
+    }
+    if (clippedDstPoint.fX < 0) {
+        clippedSrcRect.fLeft -= clippedDstPoint.fX;
+        clippedDstPoint.fX = 0;
+    }
+
+    // clip the top edge to src and dst bounds, adjusting dstPoint if neceessary
+    if (clippedSrcRect.fTop < 0) {
+        clippedDstPoint.fY -= clippedSrcRect.fTop;
+        clippedSrcRect.fTop = 0;
+    }
+    if (clippedDstPoint.fY < 0) {
+        clippedSrcRect.fTop -= clippedDstPoint.fY;
+        clippedDstPoint.fY = 0;
+    }
+    
+    // clip the right edge to the src and dst bounds.
+    if (clippedSrcRect.fRight > src->width()) {
+        clippedSrcRect.fRight = src->width();
+    }
+    if (clippedDstPoint.fX + clippedSrcRect.width() > dst->width()) {
+        clippedSrcRect.fRight = clippedSrcRect.fLeft + dst->width() - clippedDstPoint.fX;
+    }
+
+    // clip the bottom edge to the src and dst bounds.
+    if (clippedSrcRect.fBottom > src->height()) {
+        clippedSrcRect.fBottom = src->height();
+    }
+    if (clippedDstPoint.fY + clippedSrcRect.height() > dst->height()) {
+        clippedSrcRect.fBottom = clippedSrcRect.fTop + dst->height() - clippedDstPoint.fY;
+    }
+  
+    // The above clipping steps may have inverted the rect if it didn't intersect either the src or
+    // dst bounds.
+    if (clippedSrcRect.isEmpty()) {
+        return true;
+    }
+
+    bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
+    GrAssert(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
+    return result;
+}
+
+bool GrDrawTarget::canCopySurface(GrSurface* dst,
+                                  GrSurface* src,
+                                  const SkIRect& srcRect,
+                                  const SkIPoint& dstPoint) {
+    // Check that the read/write rects are contained within the src/dst bounds.
+    GrAssert(!srcRect.isEmpty());
+    GrAssert(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
+    GrAssert(dstPoint.fX >= 0 && dstPoint.fY >= 0);
+    GrAssert(dstPoint.fX + srcRect.width() <= dst->width() &&
+             dstPoint.fY + srcRect.height() <= dst->height());
+
+    return NULL != dst->asRenderTarget() && NULL != src->asTexture();
+}
+
+bool GrDrawTarget::onCopySurface(GrSurface* dst,
+                                 GrSurface* src,
+                                 const SkIRect& srcRect,
+                                 const SkIPoint& dstPoint) {
+    if (!GrDrawTarget::canCopySurface(dst, src, srcRect, dstPoint)) {
+        return false;
+    }
+
+    GrRenderTarget* rt = dst->asRenderTarget();
+    GrTexture* tex = src->asTexture();
+
+    GrDrawTarget::AutoStateRestore asr(this, kReset_ASRInit);
+    this->drawState()->setRenderTarget(rt);
+    SkMatrix matrix;
+    matrix.setTranslate(SkIntToScalar(srcRect.fLeft - dstPoint.fX),
+                        SkIntToScalar(srcRect.fTop - dstPoint.fY));
+    matrix.postIDiv(tex->width(), tex->height());
+    this->drawState()->createTextureEffect(0, tex, matrix);
+    SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX,
+                                        dstPoint.fY,
+                                        srcRect.width(),
+                                        srcRect.height());
+    this->drawSimpleRect(dstRect);
+    return true;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_INST_COUNT(GrDrawTargetCaps)
 
 void GrDrawTargetCaps::reset() {
     f8BitPaletteSupport = false;
     fNPOTTextureTileSupport = false;
     fTwoSidedStencilSupport = false;
     fStencilWrapOpsSupport = false;
     fHWAALineSupport = false;
@@ skipping 36 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);
 }