Clip in grdrawtarget

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)
     : INHERITED(gpu->getContext())
     , fCmdBuffer(kCmdBufferInitialSizeInBytes)
     , fLastState(NULL)
-    , fLastClip(NULL)
     , fDstGpu(gpu)
-    , fClipSet(true)
-    , fClipProxyState(kUnknown_ClipProxyState)
     , fVertexPool(*vertexPool)
     , fIndexPool(*indexPool)
     , fFlushing(false)
     , fDrawID(0) {
 
     fDstGpu->ref();
     fCaps.reset(SkRef(fDstGpu->caps()));
 
     SkASSERT(vertexPool);
     SkASSERT(indexPool);
@@ skipping 132 matching lines @@
         vertColor = (GrColor*) ((intptr_t) vertColor + vstride);
     }
 
     this->setIndexSourceToBuffer(this->getContext()->getQuadIndexBuffer());
     this->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6, &devBounds);
 
     // to ensure that stashing the drawState ptr is valid
     SkASSERT(this->drawState() == drawState);
 }
 
-bool GrInOrderDrawBuffer::quickInsideClip(const SkRect& devBounds) {
-    if (!this->getDrawState().isClipState()) {
-        return true;
-    }
-    if (kUnknown_ClipProxyState == fClipProxyState) {
-        SkIRect rect;
-        bool iior;
-        this->getClip()->getConservativeBounds(this->getDrawState().getRenderTarget(), &rect, &iior);
-        if (iior) {
-            // The clip is a rect. We will remember that in fProxyClip. It is common for an edge (or
-            // all edges) of the clip to be at the edge of the RT. However, we get that clipping for
-            // free via the viewport. We don't want to think that clipping must be enabled in this
-            // case. So we extend the clip outward from the edge to avoid these false negatives.
-            fClipProxyState = kValid_ClipProxyState;
-            fClipProxy = SkRect::Make(rect);
-
-            if (fClipProxy.fLeft <= 0) {
-                fClipProxy.fLeft = SK_ScalarMin;
-            }
-            if (fClipProxy.fTop <= 0) {
-                fClipProxy.fTop = SK_ScalarMin;
-            }
-            if (fClipProxy.fRight >= this->getDrawState().getRenderTarget()->width()) {
-                fClipProxy.fRight = SK_ScalarMax;
-            }
-            if (fClipProxy.fBottom >= this->getDrawState().getRenderTarget()->height()) {
-                fClipProxy.fBottom = SK_ScalarMax;
-            }
-        } else {
-            fClipProxyState = kInvalid_ClipProxyState;
-        }
-    }
-    if (kValid_ClipProxyState == fClipProxyState) {
-        return fClipProxy.contains(devBounds);
-    }
-    SkPoint originOffset = {SkIntToScalar(this->getClip()->fOrigin.fX),
-                            SkIntToScalar(this->getClip()->fOrigin.fY)};
-    SkRect clipSpaceBounds = devBounds;
-    clipSpaceBounds.offset(originOffset);
-    return this->getClip()->fClipStack->quickContains(clipSpaceBounds);
-}
-
-int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
+int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info,
+                                             const GrClipMaskManager::ScissorState& scissorState) {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(info.isInstanced());
 
     const GeometrySrcState& geomSrc = this->getGeomSrc();
     const GrDrawState& drawState = this->getDrawState();
 
     // we only attempt to concat the case when reserved verts are used with a client-specified index
     // buffer. To make this work with client-specified VBs we'd need to know if the VB was updated
     // between draws.
     if (kReserved_GeometrySrcType != geomSrc.fVertexSrc ||
         kBuffer_GeometrySrcType != geomSrc.fIndexSrc) {
         return 0;
     }
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
     if (kDraw_Cmd != strip_trace_bit(fCmdBuffer.back().fType)) {
         return 0;
     }
 
     Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GrVertexBuffer* vertexBuffer = poolState.fPoolVertexBuffer;
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
         draw->vertexBuffer() != vertexBuffer ||
-        draw->indexBuffer() != geomSrc.fIndexBuffer) {
+        draw->indexBuffer() != geomSrc.fIndexBuffer ||
+        draw->fScissorState != scissorState) {
         return 0;
     }
     // info does not yet account for the offset from the start of the pool's VB while the previous
     // draw record does.
     int adjustedStartVertex = poolState.fPoolStartVertex + info.startVertex();
     if (draw->fInfo.startVertex() + draw->fInfo.vertexCount() != adjustedStartVertex) {
         return 0;
     }
 
     SkASSERT(poolState.fPoolStartVertex == draw->fInfo.startVertex() + draw->fInfo.vertexCount());
@@ skipping 16 matching lines @@
             fGpuCmdMarkers.back().addSet(this->getActiveTraceMarkers());
         } else {
             fGpuCmdMarkers.push_back(this->getActiveTraceMarkers());
             draw->fType = add_trace_bit(draw->fType);
         }
     }
 
     return instancesToConcat;
 }
 
-class AutoClipReenable {
-public:
-    AutoClipReenable() : fDrawState(NULL) {}
-    ~AutoClipReenable() {
-        if (fDrawState) {
-            fDrawState->enableState(GrDrawState::kClip_StateBit);
-        }
-    }
-    void set(GrDrawState* drawState) {
-        if (drawState->isClipState()) {
-            fDrawState = drawState;
-            drawState->disableState(GrDrawState::kClip_StateBit);
-        }
-    }
-private:
-    GrDrawState*    fDrawState;
-};
-
-void GrInOrderDrawBuffer::onDraw(const DrawInfo& info) {
+void GrInOrderDrawBuffer::onDraw(const DrawInfo& info,
+                                 const GrClipMaskManager::ScissorState& scissorState) {
 
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GrDrawState& drawState = this->getDrawState();
-    AutoClipReenable acr;
 
-    if (drawState.isClipState() &&
-        info.getDevBounds() &&
-        this->quickInsideClip(*info.getDevBounds())) {
-        acr.set(this->drawState());
-    }
-
-    this->recordClipIfNecessary();
     this->recordStateIfNecessary();
 
     const GrVertexBuffer* vb;
     if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
         vb = this->getGeomSrc().fVertexBuffer;
     } else {
         vb = poolState.fPoolVertexBuffer;
     }
 
     const GrIndexBuffer* ib = NULL;
     if (info.isIndexed()) {
         if (kBuffer_GeometrySrcType == this->getGeomSrc().fIndexSrc) {
             ib = this->getGeomSrc().fIndexBuffer;
         } else {
             ib = poolState.fPoolIndexBuffer;
         }
     }
 
     Draw* draw;
     if (info.isInstanced()) {
-        int instancesConcated = this->concatInstancedDraw(info);
+        int instancesConcated = this->concatInstancedDraw(info, scissorState);
         if (info.instanceCount() > instancesConcated) {
-            draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, vb, ib));
+            draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState, vb, ib));
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
-        draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, vb, ib));
+        draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState, vb, ib));
     }
     this->recordTraceMarkersIfNecessary();
 
     // Adjust the starting vertex and index when we are using reserved or array sources to
     // compensate for the fact that the data was inserted into a larger vb/ib owned by the pool.
     if (kBuffer_GeometrySrcType != this->getGeomSrc().fVertexSrc) {
         size_t bytes = (info.vertexCount() + info.startVertex()) * drawState.getVertexStride();
         poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, bytes);
         draw->fInfo.adjustStartVertex(poolState.fPoolStartVertex);
     }
     
     if (info.isIndexed() && kBuffer_GeometrySrcType != this->getGeomSrc().fIndexSrc) {
         size_t bytes = (info.indexCount() + info.startIndex()) * sizeof(uint16_t);
         poolState.fUsedPoolIndexBytes = SkTMax(poolState.fUsedPoolIndexBytes, bytes);
         draw->fInfo.adjustStartIndex(poolState.fPoolStartIndex);
     }
 }
 
-void GrInOrderDrawBuffer::onStencilPath(const GrPath* path, GrPathRendering::FillType fill) {
-    this->recordClipIfNecessary();
+void GrInOrderDrawBuffer::onStencilPath(const GrPath* path,
+                                        const GrClipMaskManager::ScissorState& scissorState,
+                                        const GrStencilSettings& stencilSettings) {
     // Only compare the subset of GrDrawState relevant to path stenciling?
     this->recordStateIfNecessary();
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath, (path));
-    sp->fFill = fill;
+    sp->fScissorState = scissorState;
+    sp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrPath* path,
-                                     GrPathRendering::FillType fill,
+                                     const GrClipMaskManager::ScissorState& scissorState,
+                                     const GrStencilSettings& stencilSettings,
                                      const GrDeviceCoordTexture* dstCopy) {
-    this->recordClipIfNecessary();
     // TODO: Only compare the subset of GrDrawState relevant to path covering?
     this->recordStateIfNecessary();
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
-    dp->fFill = fill;
     if (dstCopy) {
         dp->fDstCopy = *dstCopy;
     }
+    dp->fScissorState = scissorState;
+    dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrPathRange* pathRange,
-                                      const uint32_t indices[], int count,
-                                      const float transforms[], PathTransformType transformsType,
-                                      GrPathRendering::FillType fill,
+                                      const uint32_t indices[],
+                                      int count,
+                                      const float transforms[],
+                                      PathTransformType transformsType,
+                                      const GrClipMaskManager::ScissorState& scissorState,
+                                      const GrStencilSettings& stencilSettings,
                                       const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transforms);
 
-    this->recordClipIfNecessary();
     this->recordStateIfNecessary();
 
     int sizeOfIndices = sizeof(uint32_t) * count;
     int sizeOfTransforms = sizeof(float) * count *
                            GrPathRendering::PathTransformSize(transformsType);
 
     DrawPaths* dp = GrNEW_APPEND_WITH_DATA_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange),
                                                        sizeOfIndices + sizeOfTransforms);
     memcpy(dp->indices(), indices, sizeOfIndices);
     dp->fCount = count;
     memcpy(dp->transforms(), transforms, sizeOfTransforms);
     dp->fTransformsType = transformsType;
-    dp->fFill = fill;
+    dp->fScissorState = scissorState;
+    dp->fStencilSettings = stencilSettings;
     if (dstCopy) {
         dp->fDstCopy = *dstCopy;
     }
 
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onClear(const SkIRect* rect, GrColor color,
                                   bool canIgnoreRect, GrRenderTarget* renderTarget) {
     SkIRect r;
@@ skipping 39 matching lines @@
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
 
     fCmdBuffer.reset();
     fLastState = NULL;
-    fLastClip = NULL;
     fVertexPool.reset();
     fIndexPool.reset();
     fGpuCmdMarkers.reset();
-    fClipSet = true;
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
     this->getContext()->getFontCache()->updateTextures();
 
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
 
     if (fCmdBuffer.empty()) {
         return;
     }
 
     GrAutoTRestore<bool> flushRestore(&fFlushing);
     fFlushing = true;
 
     fVertexPool.unmap();
     fIndexPool.unmap();
 
-    GrDrawTarget::AutoClipRestore acr(fDstGpu);
-    AutoGeometryAndStatePush agasp(fDstGpu, kPreserve_ASRInit);
-
     GrDrawState* prevDrawState = SkRef(fDstGpu->drawState());
 
     CmdBuffer::Iter iter(fCmdBuffer);
 
     int currCmdMarker = 0;
     fDstGpu->saveActiveTraceMarkers();
 
     while (iter.next()) {
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
@@ skipping 24 matching lines @@
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
 void GrInOrderDrawBuffer::Draw::execute(GrClipTarget* gpu) {
     gpu->setVertexSourceToBuffer(this->vertexBuffer());
     if (fInfo.isIndexed()) {
         gpu->setIndexSourceToBuffer(this->indexBuffer());
     }
-    gpu->executeDraw(fInfo);
+    gpu->executeDraw(fInfo, fScissorState);
 }
 
 void GrInOrderDrawBuffer::StencilPath::execute(GrClipTarget* gpu) {
-    gpu->stencilPath(this->path(), fFill);
+    gpu->executeStencilPath(this->path(), fScissorState, fStencilSettings);
 }
 
 void GrInOrderDrawBuffer::DrawPath::execute(GrClipTarget* gpu) {
-    gpu->executeDrawPath(this->path(), fFill, fDstCopy.texture() ? &fDstCopy : NULL);
+    gpu->executeDrawPath(this->path(), fScissorState, fStencilSettings,
+                         fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
 void GrInOrderDrawBuffer::DrawPaths::execute(GrClipTarget* gpu) {
     gpu->executeDrawPaths(this->pathRange(), this->indices(), fCount, this->transforms(),
-                          fTransformsType, fFill, fDstCopy.texture() ? &fDstCopy : NULL);
+                          fTransformsType, fScissorState, fStencilSettings,
+                          fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
 void GrInOrderDrawBuffer::SetState::execute(GrClipTarget* gpu) {
     gpu->setDrawState(&fState);
 }
 
-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(GrClipTarget* gpu) {
     if (GrColor_ILLEGAL == fColor) {
         gpu->discard(this->renderTarget());
     } else {
         gpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
 void GrInOrderDrawBuffer::ClearStencilClip::execute(GrClipTarget* gpu) {
         gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
@@ skipping 212 matching lines @@
             // So here we just destruct the previous state and reinit with a new copy of curr.
             // Note that this goes away when we move GrIODB over to taking optimized snapshots
             // of draw states.
             fLastState->~GrDrawState();
             SkNEW_PLACEMENT_ARGS(fLastState, GrDrawState, (curr));
             this->convertDrawStateToPendingExec(fLastState);
             break;
     }
 }
 
-void GrInOrderDrawBuffer::recordClipIfNecessary() {
-    if (this->getDrawState().isClipState() &&
-        fClipSet &&
-        (!fLastClip || *fLastClip != *this->getClip())) {
-        fLastClip = &GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetClip, (this->getClip()))->fClipData;
-        this->recordTraceMarkersIfNecessary();
-        fClipSet = false;
-    }
-}
-
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         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;
-}