clear stencil clip on draw target

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
 #include "GrDrawTargetCaps.h"
 #include "GrTextStrike.h"
 #include "GrGpu.h"
 #include "GrTemplates.h"
 #include "GrTexture.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrGpu* gpu,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
-    : GrDrawTarget(gpu->getContext())
+    : INHERITED(gpu->getContext())
     , fCmdBuffer(kCmdBufferInitialSizeInBytes)
     , fLastState(NULL)
     , fLastClip(NULL)
     , fDstGpu(gpu)
     , fClipSet(true)
     , fClipProxyState(kUnknown_ClipProxyState)
     , fVertexPool(*vertexPool)
     , fIndexPool(*indexPool)
     , fFlushing(false)
     , fDrawID(0) {
@@ skipping 396 matching lines @@
         rect = &r;
     }
     Clear* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Clear, (renderTarget));
     GrColorIsPMAssert(color);
     clr->fColor = color;
     clr->fRect = *rect;
     clr->fCanIgnoreRect = canIgnoreRect;
     this->recordTraceMarkersIfNecessary();
 }
 
+void GrInOrderDrawBuffer::clearStencilClip(const SkIRect& rect,
+                                           bool insideClip,
+                                           GrRenderTarget* renderTarget) {
+    if (NULL == renderTarget) {
+        renderTarget = this->drawState()->getRenderTarget();
+        SkASSERT(renderTarget);
+    }
+    ClearStencilClip* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, ClearStencilClip, (renderTarget));
+    clr->fRect = rect;
+    clr->fInsideClip = insideClip;
+    this->recordTraceMarkersIfNecessary();
+}
+
 void GrInOrderDrawBuffer::discard(GrRenderTarget* renderTarget) {
     if (!this->caps()->discardRenderTargetSupport()) {
         return;
     }
     if (NULL == renderTarget) {
         renderTarget = this->drawState()->getRenderTarget();
         SkASSERT(renderTarget);
     }
     Clear* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Clear, (renderTarget));
     clr->fColor = GrColor_ILLEGAL;
@@ skipping 69 matching lines @@
 
     fDstGpu->restoreActiveTraceMarkers();
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     fDstGpu->setDrawState(prevDrawState);
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
-void GrInOrderDrawBuffer::Draw::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::Draw::execute(GrClipTarget* gpu) {
     gpu->setVertexSourceToBuffer(this->vertexBuffer());
     if (fInfo.isIndexed()) {
         gpu->setIndexSourceToBuffer(this->indexBuffer());
     }
     gpu->executeDraw(fInfo);
 }
 
-void GrInOrderDrawBuffer::StencilPath::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::StencilPath::execute(GrClipTarget* gpu) {
     gpu->stencilPath(this->path(), fFill);
 }
 
-void GrInOrderDrawBuffer::DrawPath::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::DrawPath::execute(GrClipTarget* gpu) {
     gpu->executeDrawPath(this->path(), fFill, fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
-void GrInOrderDrawBuffer::DrawPaths::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::DrawPaths::execute(GrClipTarget* gpu) {
     gpu->executeDrawPaths(this->pathRange(), this->indices(), fCount, this->transforms(),
                           fTransformsType, fFill, fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
-void GrInOrderDrawBuffer::SetState::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::SetState::execute(GrClipTarget* gpu) {
     gpu->setDrawState(&fState);
 }
 
-void GrInOrderDrawBuffer::SetClip::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::SetClip::execute(GrClipTarget* gpu) {
     // Our fClipData is referenced directly, so we must remain alive for the entire
     // duration of the flush (after which the gpu's previous clip is restored).
     gpu->setClip(&fClipData);
 }
 
-void GrInOrderDrawBuffer::Clear::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::Clear::execute(GrClipTarget* gpu) {
     if (GrColor_ILLEGAL == fColor) {
         gpu->discard(this->renderTarget());
     } else {
         gpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
-void GrInOrderDrawBuffer::CopySurface::execute(GrDrawTarget* gpu) {
+void GrInOrderDrawBuffer::ClearStencilClip::execute(GrClipTarget* gpu) {
+        gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
+}
+
+void GrInOrderDrawBuffer::CopySurface::execute(GrClipTarget* gpu) {
     gpu->copySurface(this->dst(), this->src(), fSrcRect, fDstPoint);
 }
 
 bool GrInOrderDrawBuffer::onCopySurface(GrSurface* dst,
                                         GrSurface* src,
                                         const SkIRect& srcRect,
                                         const SkIPoint& dstPoint) {
     if (fDstGpu->canCopySurface(dst, src, srcRect, dstPoint)) {
         CopySurface* cs = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, CopySurface, (dst, src));
         cs->fSrcRect = srcRect;
@@ skipping 265 matching lines @@
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }