Move clip off of draw target

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 396 matching lines @@
         }
 
         AutoCheckFlush acf(this);
         GrPipelineBuilder pipelineBuilder;
         GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, paint, &acf);
         if (NULL == target) {
             return;
         }
 
         GR_CREATE_TRACE_MARKER("GrContext::drawPaintWithPerspective", target);
-        target->drawRect(&pipelineBuilder, paint->getColor(), SkMatrix::I(), r, NULL, &localMatrix);
+        target->drawRect(&pipelineBuilder,
+                         paint->getColor(),
+                         SkMatrix::I(),
+                         r,
+                         NULL,
+                         &localMatrix);
     }
 }
 
 #ifdef SK_DEVELOPER
 void GrContext::dumpFontCache() const {
     fFontCache->dump();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 97 matching lines @@
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRect", target);
     SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getStrokeRec().getWidth();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
         pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
-        bool checkClip = false;
-        if (this->getClip()) {
-            checkClip = true;
-            clipSpaceRTRect.offset(SkIntToScalar(this->getClip()->fOrigin.fX),
-                                   SkIntToScalar(this->getClip()->fOrigin.fY));
+        bool checkClip = fClip && GrClip::kWideOpen_ClipType != fClip->clipType();
+        if (checkClip) {
+            clipSpaceRTRect.offset(SkIntToScalar(this->getClip()->origin().fX),
+                                   SkIntToScalar(this->getClip()->origin().fY));
         }
         // Does the clip contain the entire RT?
-        if (!checkClip || target->getClip()->fClipStack->quickContains(clipSpaceRTRect)) {
+        if (!checkClip || fClip->clipStack()->quickContains(clipSpaceRTRect)) {
             SkMatrix invM;
             if (!viewMatrix.invert(&invM)) {
                 return;
             }
             // Does the rect bound the RT?
             SkPoint srcSpaceRTQuad[4];
             invM.mapRectToQuad(srcSpaceRTQuad, rtRect);
             if (rect_contains_inclusive(rect, srcSpaceRTQuad[0]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[1]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[2]) &&
@@ skipping 92 matching lines @@
                                     const SkMatrix* localMatrix) {
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target);
 
-    target->drawRect(&pipelineBuilder, paint.getColor(), viewMatrix, rectToDraw, &localRect,
+    target->drawRect(&pipelineBuilder,
+                     paint.getColor(),
+                     viewMatrix,
+                     rectToDraw,
+                     &localRect,
                      localMatrix);
 }
 
 static const GrGeometryProcessor* set_vertex_attributes(const SkPoint* texCoords,
                                                         const GrColor* colors,
                                                         int* colorOffset,
                                                         int* texOffset,
                                                         GrColor color,
                                                         const SkMatrix& viewMatrix) {
     *texOffset = -1;
@@ skipping 97 matching lines @@
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawRRect(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(),
-                                  rrect, strokeRec)) {
+    if (!fOvalRenderer->drawRRect(target,
+                                  &pipelineBuilder,
+                                  color,
+                                  viewMatrix,
+                                  paint.isAntiAlias(),
+                                  rrect,
+                                  strokeRec)) {
         SkPath path;
         path.addRRect(rrect);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(GrRenderTarget* rt,
                            const GrPaint& paint,
                            const SkMatrix& viewMatrix,
                            const SkRRect& outer,
                            const SkRRect& inner) {
     if (outer.isEmpty()) {
        return;
     }
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, &paint, &acf);
 
     GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target);
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawDRRect(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(),
-                                   outer, inner)) {
+    if (!fOvalRenderer->drawDRRect(target,
+                                   &pipelineBuilder,
+                                   color,
+                                   viewMatrix,
+                                   paint.isAntiAlias(),
+                                   outer,
+                                   inner)) {
         SkPath path;
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, fillRec);
     }
 }
@@ skipping 21 matching lines @@
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawOval(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(),
-                                 oval, strokeRec)) {
+    if (!fOvalRenderer->drawOval(target,
+                                 &pipelineBuilder,
+                                 color,
+                                 viewMatrix,
+                                 paint.isAntiAlias(),
+                                 oval,
+                                 strokeRec)) {
         SkPath path;
         path.addOval(oval);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             GrPipelineBuilder* pipelineBuilder,
@@ skipping 113 matching lines @@
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     bool useCoverageAA = paint.isAntiAlias() &&
         !pipelineBuilder.getRenderTarget()->isMultisampled();
 
     if (useCoverageAA && strokeRec.getWidth() < 0 && !path.isConvex()) {
         // Concave AA paths are expensive - try to avoid them for special cases
         SkRect rects[2];
 
         if (is_nested_rects(target, &pipelineBuilder, color, viewMatrix, path, strokeRec, rects)) {
-            fAARectRenderer->fillAANestedRects(target, &pipelineBuilder, color, viewMatrix,rects);
+            fAARectRenderer->fillAANestedRects(target, &pipelineBuilder, color, viewMatrix, rects);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType() ||
-        !fOvalRenderer->drawOval(target, &pipelineBuilder, color, viewMatrix, paint.isAntiAlias(),
-                                 ovalRect, strokeRec)) {
+        !fOvalRenderer->drawOval(target,
+                                 &pipelineBuilder,
+                                 color,
+                                 viewMatrix,
+                                 paint.isAntiAlias(),
+                                 ovalRect,
+                                 strokeRec)) {
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 void GrContext::internalDrawPath(GrDrawTarget* target,
                                  GrPipelineBuilder* pipelineBuilder,
                                  const SkMatrix& viewMatrix,
                                  GrColor color,
                                  bool useAA,
@@ skipping 183 matching lines @@
     // SW-rasterized clip while issuing a draw). So we push the current geometry state before
     // drawing a rect to the render target.
     // The bracket ensures we pop the stack if we wind up flushing below.
     {
         GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL, NULL);
         GrDrawTarget::AutoGeometryPush agp(drawTarget);
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.addColorProcessor(fp);
         pipelineBuilder.setRenderTarget(renderTarget);
-        drawTarget->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, matrix,
+        drawTarget->drawSimpleRect(&pipelineBuilder,
+                                   GrColor_WHITE,
+                                   matrix,
                                    SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)));
     }
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flushSurfaceWrites(surface);
     }
 
     return true;
 }
 
@@ skipping 101 matching lines @@
                 // clear to the caller that a draw operation (i.e., drawSimpleRect)
                 // can be invoked in this method
                 {
                     GrDrawTarget::AutoGeometryPush agp(fDrawBuffer);
                     GrPipelineBuilder pipelineBuilder;
                     SkASSERT(fp);
                     pipelineBuilder.addColorProcessor(fp);
 
                     pipelineBuilder.setRenderTarget(tempTexture->asRenderTarget());
                     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-                    fDrawBuffer->drawSimpleRect(&pipelineBuilder, GrColor_WHITE, SkMatrix::I(),
+                    fDrawBuffer->drawSimpleRect(&pipelineBuilder,
+                                                GrColor_WHITE,
+                                                SkMatrix::I(),
                                                 rect);
                     // we want to read back from the scratch's origin
                     left = 0;
                     top = 0;
                     target = tempTexture->asRenderTarget();
                 }
                 this->flushSurfaceWrites(target);
             }
         }
     }
@@ skipping 79 matching lines @@
                                        GrRenderTarget* rt,
                                        const GrPaint* paint,
                                        const AutoCheckFlush* acf) {
     if (NULL == fGpu) {
         return NULL;
     }
 
     if (pipelineBuilder) {
         ASSERT_OWNED_RESOURCE(rt);
         SkASSERT(rt && paint && acf);
-        pipelineBuilder->setFromPaint(*paint, rt);
-        pipelineBuilder->setState(GrPipelineBuilder::kClip_StateBit,
-                                  fClip && !fClip->fClipStack->isWideOpen());
+        pipelineBuilder->setFromPaint(*paint, rt, fClip);
     }
-    fDrawBuffer->setClip(fClip);
     return fDrawBuffer;
 }
 
 /*
  * This method finds a path renderer that can draw the specified path on
  * the provided target.
  * Due to its expense, the software path renderer has split out so it can
  * can be individually allowed/disallowed via the "allowSW" boolean.
  */
 GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
@@ skipping 158 matching lines @@
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }