Clip in grdrawtarget

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 460 matching lines @@
     }
 }
 
 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)) {
+        // Setup clip
+        GrClipMaskManager::ScissorState scissorState;
+        GrDrawState::AutoRestoreEffects are;
+        GrDrawState::AutoRestoreStencil ars;
+        if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+            return;
+        }
+
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = startIndex;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = indexCount;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
         // TODO: We should continue with incorrect blending.
         if (!this->setupDstReadIfNecessary(&info)) {
             return;
         }
-        this->onDraw(info);
+        this->onDraw(info, scissorState);
     }
 }
 
 void GrDrawTarget::drawNonIndexed(GrPrimitiveType type,
                                   int startVertex,
                                   int vertexCount,
                                   const SkRect* devBounds) {
     if (vertexCount > 0 && this->checkDraw(type, startVertex, -1, vertexCount, -1)) {
+        // Setup clip
+        GrClipMaskManager::ScissorState scissorState;
+        GrDrawState::AutoRestoreEffects are;
+        GrDrawState::AutoRestoreStencil ars;
+        if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+            return;
+        }
+
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = 0;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = 0;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
+
         // TODO: We should continue with incorrect blending.
         if (!this->setupDstReadIfNecessary(&info)) {
             return;
         }
-        this->onDraw(info);
+        this->onDraw(info, scissorState);
     }
 }
 
+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() {
+    GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
+        kInvert_StencilOp,
+        kInvert_StencilOp,
+        kAlwaysIfInClip_StencilFunc,
+        0xFFFF, 0xFFFF, 0xFFFF);
+    return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
+}
+
+void GrDrawTarget::getPathStencilSettingsForFilltype(GrPathRendering::FillType fill,
+                                                     GrStencilSettings* outStencilSettings) {
+
+    switch (fill) {
+        default:
+            SkFAIL("Unexpected path fill.");
+        case GrPathRendering::kWinding_FillType:
+            *outStencilSettings = winding_path_stencil_settings();
+            break;
+        case GrPathRendering::kEvenOdd_FillType:
+            *outStencilSettings = even_odd_path_stencil_settings();
+            break;
+    }
+    this->clipMaskManager()->adjustPathStencilParams(outStencilSettings);
+}
+
 void GrDrawTarget::stencilPath(const GrPath* path, GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
-    this->onStencilPath(path, fill);
+
+    // Setup clip
+    GrClipMaskManager::ScissorState scissorState;
+    GrDrawState::AutoRestoreEffects are;
+    GrDrawState::AutoRestoreStencil ars;
+    if (!this->setupClip(NULL, &are, &ars, &scissorState)) {
+        return;
+    }
+
+    // set stencil settings for path
+    GrStencilSettings stencilSettings;
+    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+
+    this->onStencilPath(path, scissorState, stencilSettings);
 }
 
 void GrDrawTarget::drawPath(const GrPath* path, GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path rendering.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
 
     SkRect devBounds = path->getBounds();
     SkMatrix viewM = this->drawState()->getViewMatrix();
     viewM.mapRect(&devBounds);
 
+    // Setup clip
+    GrClipMaskManager::ScissorState scissorState;
+    GrDrawState::AutoRestoreEffects are;
+    GrDrawState::AutoRestoreStencil ars;
+    if (!this->setupClip(&devBounds, &are, &ars, &scissorState)) {
+       return;
+    }
+
+    // set stencil settings for path
+    GrStencilSettings stencilSettings;
+    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+
     GrDeviceCoordTexture dstCopy;
     if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
         return;
     }
 
-    this->onDrawPath(path, fill, dstCopy.texture() ? &dstCopy : NULL);
+    this->onDrawPath(path, scissorState, stencilSettings, dstCopy.texture() ? &dstCopy : NULL);
 }
 
 void GrDrawTarget::drawPaths(const GrPathRange* pathRange,
                              const uint32_t indices[], int count,
                              const float transforms[], PathTransformType transformsType,
                              GrPathRendering::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transforms);
 
+    // Setup clip
+    GrClipMaskManager::ScissorState scissorState;
+    GrDrawState::AutoRestoreEffects are;
+    GrDrawState::AutoRestoreStencil ars;
+
+    if (!this->setupClip(NULL, &are, &ars, &scissorState)) {
+        return;
+    }
+
+    // set stencil settings for path
+    GrStencilSettings stencilSettings;
+    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+
     // Don't compute a bounding box for setupDstReadIfNecessary(), we'll opt
     // instead for it to just copy the entire dst. Realistically this is a moot
     // point, because any context that supports NV_path_rendering will also
     // support NV_blend_equation_advanced.
     GrDeviceCoordTexture dstCopy;
     if (!this->setupDstReadIfNecessary(&dstCopy, NULL)) {
         return;
     }
 
-    this->onDrawPaths(pathRange, indices, count, transforms, transformsType, fill,
-                      dstCopy.texture() ? &dstCopy : NULL);
+    this->onDrawPaths(pathRange, indices, count, transforms, transformsType, scissorState,
+                      stencilSettings, dstCopy.texture() ? &dstCopy : NULL);
 }
 
 typedef GrTraceMarkerSet::Iter TMIter;
 void GrDrawTarget::saveActiveTraceMarkers() {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(0 == fStoredTraceMarkers.count());
         fStoredTraceMarkers.addSet(fActiveTraceMarkers);
         for (TMIter iter = fStoredTraceMarkers.begin(); iter != fStoredTraceMarkers.end(); ++iter) {
             this->removeGpuTraceMarker(&(*iter));
         }
@@ skipping 39 matching lines @@
                                         const SkRect* devBounds) {
     if (!verticesPerInstance || !indicesPerInstance) {
         return;
     }
 
     int maxInstancesPerDraw = this->indexCountInCurrentSource() / indicesPerInstance;
     if (!maxInstancesPerDraw) {
         return;
     }
 
+    // Setup clip
+    GrClipMaskManager::ScissorState scissorState;
+    GrDrawState::AutoRestoreEffects are;
+    GrDrawState::AutoRestoreStencil ars;
+    if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+        return;
+    }
+
     DrawInfo info;
     info.fPrimitiveType = type;
     info.fStartIndex = 0;
     info.fStartVertex = 0;
     info.fIndicesPerInstance = indicesPerInstance;
     info.fVerticesPerInstance = verticesPerInstance;
 
     // Set the same bounds for all the draws.
     if (devBounds) {
         info.setDevBounds(*devBounds);
     }
     // TODO: We should continue with incorrect blending.
     if (!this->setupDstReadIfNecessary(&info)) {
         return;
     }
 
     while (instanceCount) {
         info.fInstanceCount = SkTMin(instanceCount, maxInstancesPerDraw);
         info.fVertexCount = info.fInstanceCount * verticesPerInstance;
         info.fIndexCount = info.fInstanceCount * indicesPerInstance;
 
         if (this->checkDraw(type,
                             info.fStartVertex,
                             info.fStartIndex,
                             info.fVertexCount,
                             info.fIndexCount)) {
-            this->onDraw(info);
+            this->onDraw(info, scissorState);
         }
         info.fStartVertex += info.fVertexCount;
         instanceCount -= info.fInstanceCount;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
@@ skipping 458 matching lines @@
 
 uint32_t GrDrawTargetCaps::CreateUniqueID() {
     static int32_t gUniqueID = SK_InvalidUniqueID;
     uint32_t id;
     do {
         id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1);
     } while (id == SK_InvalidUniqueID);
     return id;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool GrClipTarget::setupClip(const SkRect* devBounds,
+                             GrDrawState::AutoRestoreEffects* are,
+                             GrDrawState::AutoRestoreStencil* ars,
+                             GrClipMaskManager::ScissorState* scissorState) {
+    return fClipMaskManager.setupClipping(this->getClip(),
+                                          devBounds,
+                                          are,
+                                          ars,
+                                          scissorState);
+}