Revert of Pass clip to context

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 344 matching lines @@
      * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
      * the client will resolve to a texture).
      *
      * @param  desc     description of the object to create.
      *
      * @return GrTexture object or NULL on failure.
      */
      GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
 
     ///////////////////////////////////////////////////////////////////////////
+    // Clip state
+    /**
+     * Gets the current clip.
+     * @return the current clip.
+     */
+    const GrClip* getClip() const { return fClip; }
+
+    /**
+     * Sets the clip.
+     * @param clipData  the clip to set.
+     */
+    void setClip(const GrClip* clipData) { fClip = clipData; }
+
+    ///////////////////////////////////////////////////////////////////////////
     // Draws
 
     /**
      * Clear the entire or rect of the render target, ignoring any clips.
      * @param rect  the rect to clear or the whole thing if rect is NULL.
      * @param color the color to clear to.
      * @param canIgnoreRect allows partial clears to be converted to whole
      *                      clears on platforms for which that is cheap
      * @param target The render target to clear.
      */
     void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect, GrRenderTarget* target);
 
     /**
      *  Draw everywhere (respecting the clip) with the paint.
      */
-    void drawPaint(GrRenderTarget*, const GrClip&, const GrPaint&, const SkMatrix& viewMatrix);
+    void drawPaint(GrRenderTarget*, const GrPaint&, const SkMatrix& viewMatrix);
 
     /**
      *  Draw the rect using a paint.
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
      *  @param strokeInfo   the stroke information (width, join, cap), and.
      *                      the dash information (intervals, count, phase).
      *                      If strokeInfo == NULL, then the rect is filled.
      *                      Otherwise, if stroke width == 0, then the stroke
      *                      is always a single pixel thick, else the rect is
      *                      mitered/beveled stroked based on stroke width.
      *  The rects coords are used to access the paint (through texture matrix)
      */
     void drawRect(GrRenderTarget*,
-                  const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect&,
                   const GrStrokeInfo* strokeInfo = NULL);
 
     /**
      * Maps a rectangle of shader coordinates to a rectangle and draws that rectangle
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix which applies to rectToDraw
      * @param rectToDraw    the rectangle to draw
      * @param localRect     the rectangle of shader coordinates applied to rectToDraw
      * @param localMatrix   an optional matrix to transform the shader coordinates before applying
      *                      to rectToDraw
      */
     void drawNonAARectToRect(GrRenderTarget*,
-                             const GrClip&,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rectToDraw,
                              const SkRect& localRect,
                              const SkMatrix* localMatrix = NULL);
 
     /**
      * Draws a non-AA rect with paint and a localMatrix
      */
     void drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
-                                      const GrClip& clip,
                                       const GrPaint& paint,
                                       const SkMatrix& viewMatrix,
                                       const SkRect& rect,
                                       const SkMatrix& localMatrix) {
-        this->drawNonAARectToRect(rt, clip, paint, viewMatrix, rect, rect, &localMatrix);
+        this->drawNonAARectToRect(rt, paint, viewMatrix, rect, rect, &localMatrix);
     }
 
     /**
      *  Draw a roundrect using a paint.
      *
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
      *  @param rrect        the roundrect to draw
      *  @param strokeInfo   the stroke information (width, join, cap) and
      *                      the dash information (intervals, count, phase).
      */
     void drawRRect(GrRenderTarget*,
-                   const GrClip&,
                    const GrPaint&,
                    const SkMatrix& viewMatrix,
                    const SkRRect& rrect,
                    const GrStrokeInfo&);
 
     /**
      *  Shortcut for drawing an SkPath consisting of nested rrects using a paint.
      *  Does not support stroking. The result is undefined if outer does not contain
      *  inner.
      *
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
      *  @param outer        the outer roundrect
      *  @param inner        the inner roundrect
      */
     void drawDRRect(GrRenderTarget*,
-                    const GrClip&,
                     const GrPaint&,
                     const SkMatrix& viewMatrix,
                     const SkRRect& outer,
                     const SkRRect& inner);
 
 
     /**
      * Draws a path.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix
      * @param path          the path to draw
      * @param strokeInfo    the stroke information (width, join, cap) and
      *                      the dash information (intervals, count, phase).
      */
     void drawPath(GrRenderTarget*,
-                  const GrClip&,
                   const GrPaint&,
                   const SkMatrix& viewMatrix,
                   const SkPath&,
                   const GrStrokeInfo&);
 
     /**
      * Draws vertices with a paint.
      *
      * @param   paint           describes how to color pixels.
      * @param   viewMatrix      transformation matrix
      * @param   primitiveType   primitives type to draw.
      * @param   vertexCount     number of vertices.
      * @param   positions       array of vertex positions, required.
      * @param   texCoords       optional array of texture coordinates used
      *                          to access the paint.
      * @param   colors          optional array of per-vertex colors, supercedes
      *                          the paint's color field.
      * @param   indices         optional array of indices. If NULL vertices
      *                          are drawn non-indexed.
      * @param   indexCount      if indices is non-null then this is the
      *                          number of indices.
      */
     void drawVertices(GrRenderTarget*,
-                      const GrClip&,
                       const GrPaint& paint,
                       const SkMatrix& viewMatrix,
                       GrPrimitiveType primitiveType,
                       int vertexCount,
                       const SkPoint positions[],
                       const SkPoint texs[],
                       const GrColor colors[],
                       const uint16_t indices[],
                       int indexCount);
 
     /**
      * Draws an oval.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix
      * @param oval          the bounding rect of the oval.
      * @param strokeInfo    the stroke information (width, join, cap) and
      *                      the dash information (intervals, count, phase).
      */
     void drawOval(GrRenderTarget*,
-                  const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect& oval,
                   const GrStrokeInfo& strokeInfo);
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
@@ skipping 122 matching lines @@
      * Provides a perfomance hint that the render target's contents are allowed
      * to become undefined.
      */
     void discardRenderTarget(GrRenderTarget*);
 
 #ifdef SK_DEVELOPER
     void dumpFontCache() const;
 #endif
 
     ///////////////////////////////////////////////////////////////////////////
+    // Helpers
+
+    class AutoClip : public ::SkNoncopyable {
+    public:
+        // This enum exists to require a caller of the constructor to acknowledge that the clip will
+        // initially be wide open. It also could be extended if there are other desirable initial
+        // clip states.
+        enum InitialClip {
+            kWideOpen_InitialClip,
+        };
+
+        AutoClip(GrContext* context, InitialClip SkDEBUGCODE(initialState))
+        : fContext(context) {
+            SkASSERT(kWideOpen_InitialClip == initialState);
+            fNewClipData.setClipStack(&fNewClipStack);
+
+            fOldClip = context->getClip();
+            context->setClip(&fNewClipData);
+        }
+
+        AutoClip(GrContext* context, const SkRect& newClipRect)
+        : fContext(context)
+        , fNewClipStack(newClipRect) {
+            fNewClipData.setClipStack(&fNewClipStack);
+
+            fOldClip = fContext->getClip();
+            fContext->setClip(&fNewClipData);
+        }
+
+        ~AutoClip() {
+            if (fContext) {
+                fContext->setClip(fOldClip);
+            }
+        }
+    private:
+        GrContext*        fContext;
+        const GrClip* fOldClip;
+
+        SkClipStack       fNewClipStack;
+        GrClip        fNewClipData;
+    };
+
+    class AutoWideOpenIdentityDraw {
+    public:
+        AutoWideOpenIdentityDraw(GrContext* ctx)
+            : fAutoClip(ctx, AutoClip::kWideOpen_InitialClip) {
+        }
+
+    private:
+        AutoClip fAutoClip;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
     // Functions intended for internal use only.
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
     GrFontCache* getFontCache() { return fFontCache; }
     GrLayerCache* getLayerCache() { return fLayerCache.get(); }
     GrDrawTarget* getTextTarget();
     const GrIndexBuffer* getQuadIndexBuffer() const;
     GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
     GrResourceCache* getResourceCache() { return fResourceCache; }
 
@@ skipping 22 matching lines @@
     /** Prints cache stats to the string if GR_CACHE_STATS == 1. */
     void dumpCacheStats(SkString*) const;
     void printCacheStats() const;
 
     /** Prints GPU stats to the string if GR_GPU_STATS == 1. */
     void dumpGpuStats(SkString*) const;
     void printGpuStats() const;
 
 private:
     GrGpu*                          fGpu;
+    const GrClip*                   fClip;
 
     GrResourceCache*                fResourceCache;
     GrFontCache*                    fFontCache;
     SkAutoTDelete<GrLayerCache>     fLayerCache;
 
     GrPathRendererChain*            fPathRendererChain;
     GrSoftwarePathRenderer*         fSoftwarePathRenderer;
 
     GrVertexBufferAllocPool*        fDrawBufferVBAllocPool;
     GrIndexBufferAllocPool*         fDrawBufferIBAllocPool;
@@ skipping 20 matching lines @@
     const Options                   fOptions;
 
     GrContext(const Options&); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext);
     void initMockContext();
     void initCommon();
 
     void setupDrawBuffer();
 
     class AutoCheckFlush;
-    // Sets the paint and returns the target to draw into.
-    GrDrawTarget* prepareToDraw(GrPipelineBuilder*,
-                                GrRenderTarget* rt,
-                                const GrClip&,
-                                const GrPaint* paint,
+    // Sets the paint and returns the target to draw into.  This function is overloaded to either
+    // take a GrDrawState, GrPaint, and AutoCheckFlush, or JUST an AutoCheckFlush
+    GrDrawTarget* prepareToDraw(GrPipelineBuilder*, GrRenderTarget* rt, const GrPaint* paint,
                                 const AutoCheckFlush*);
 
-    // A simpler version of the above which just returns the draw target.  Clip is *NOT* set
-    GrDrawTarget* prepareToDraw();
-
     void internalDrawPath(GrDrawTarget*,
                           GrPipelineBuilder*,
                           const SkMatrix& viewMatrix,
                           GrColor,
                           bool useAA,
                           const SkPath&,
                           const GrStrokeInfo&);
 
     GrTexture* internalRefScratchTexture(const GrSurfaceDesc&, uint32_t flags);
 
     /**
      * These functions create premul <-> unpremul effects if it is possible to generate a pair
      * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
      * return NULL.
      */
     const GrFragmentProcessor* createPMToUPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
     const GrFragmentProcessor* createUPMToPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
 
     /**
      *  This callback allows the resource cache to callback into the GrContext
      *  when the cache is still over budget after a purge.
      */
     static void OverBudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif