Convert GrAppliedClip interface to builder style

include/gpu/GrClip.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 GrClip_DEFINED
 #define GrClip_DEFINED
 
 #include "GrFragmentProcessor.h"
 #include "GrTypesPriv.h"
 
 class GrDrawContext;
 
 /**
  * Produced by GrClip. It provides a set of modifications to the drawing state that are used to
  * create the final GrPipeline for a GrBatch.
  */
 class GrAppliedClip : public SkNoncopyable {
 public:
-    GrAppliedClip() : fHasStencilClip(false), fDeviceBounds(SkRect::MakeLargest()) {}
-    GrFragmentProcessor* getClipCoverageFragmentProcessor() const {
-        return fClipCoverageFP.get();
-    }
+    GrAppliedClip(const SkRect& drawBounds) : fHasStencilClip(false), fDeviceBounds(drawBounds) {}
+
     const GrScissorState& scissorState() const { return fScissorState; }
+    GrFragmentProcessor* clipCoverageFragmentProcessor() const { return fClipCoverageFP.get(); }
     bool hasStencilClip() const { return fHasStencilClip; }
 
-    void makeStencil(bool hasStencil, const SkRect& deviceBounds) {
-        fClipCoverageFP = nullptr;
-        fScissorState.setDisabled();
-        fHasStencilClip = hasStencil;
-        fDeviceBounds = deviceBounds;
+    /**
+     * Intersects the applied clip with the provided rect. Returns false if the draw became empty.
+     */
+    bool addScissor(const SkIRect& irect) {
+        return fScissorState.intersect(irect) && fDeviceBounds.intersect(SkRect::Make(irect));
+    }
+
+    void addCoverageFP(sk_sp<GrFragmentProcessor> fp) {
+        SkASSERT(!fClipCoverageFP);

[csmartdalton, 2016/08/15 16:05:25]

This can eventually accept the bounding box and intersect it into the dev
bounds. (But GrReducedClip needs to start providing that info first.)

+        fClipCoverageFP = fp;
+    }
+
+    void addStencilClip() {
+        SkASSERT(!fHasStencilClip);

[csmartdalton, 2016/08/15 16:05:26]

ditto

+        fHasStencilClip = true;
     }
 
     /**
-     * The device bounds of the clip defaults to the scissor rect, but a tighter bounds (based
-     * on the known effect of the stencil values) can be provided.
-     */
-    void makeScissoredStencil(const SkIRect& scissor, const SkRect* deviceBounds = nullptr) {
-        fClipCoverageFP = nullptr;
-        fScissorState.set(scissor);
-        fHasStencilClip = true;
-        if (deviceBounds) {
-            fDeviceBounds = *deviceBounds;
-            SkASSERT(scissor.contains(*deviceBounds));
-        } else {
-            fDeviceBounds = SkRect::Make(scissor);
-        }
-    }
-
-    void makeFPBased(sk_sp<GrFragmentProcessor> fp, const SkRect& deviceBounds) {
-        fClipCoverageFP = fp;
-        fScissorState.setDisabled();
-        fHasStencilClip = false;
-        fDeviceBounds = deviceBounds;
-    }
-
-    void makeScissored(SkIRect& scissor) {
-        fClipCoverageFP.reset();
-        fScissorState.set(scissor);
-        fHasStencilClip = false;
-        fDeviceBounds = SkRect::Make(scissor);
-    }
-
-    /**
-     * The device bounds of the clip defaults to the scissor rect, but a tighter bounds (based
-     * on the known effect of the fragment processor) can be provided.
-     */
-    void makeScissoredFPBased(sk_sp<GrFragmentProcessor> fp, const SkIRect& scissor,
-                              const SkRect* deviceBounds = nullptr) {
-        fClipCoverageFP = fp;
-        fScissorState.set(scissor);
-        fHasStencilClip = false;
-        if (deviceBounds) {
-            fDeviceBounds = *deviceBounds;
-            SkASSERT(scissor.contains(*deviceBounds));
-        } else {
-            fDeviceBounds = SkRect::Make(scissor);
-        }
-    }
-
-    /**
-     * Returns the device bounds of the applied clip. Ideally this considers the combined effect of
-     * all clipping techniques in play (scissor, stencil, and/or coverage fp).
+     * Returns the device bounds of the draw after clip has been applied. TODO: Ideally this would
+     * consider the combined effect of all clipping techniques in play (scissor, stencil, fp, etc.).
      */
     const SkRect& deviceBounds() const { return fDeviceBounds; }
 
 private:
+    GrScissorState             fScissorState;
     sk_sp<GrFragmentProcessor> fClipCoverageFP;
-    GrScissorState             fScissorState;
     bool                       fHasStencilClip;
     SkRect                     fDeviceBounds;
     typedef SkNoncopyable INHERITED;
 };
 
 /**
  * GrClip is an abstract base class for applying a clip. It constructs a clip mask if necessary, and
  * fills out a GrAppliedClip instructing the caller on how to set up the draw state.
  */
 class GrClip {
 public:
     virtual bool quickContains(const SkRect&) const = 0;
     virtual void getConservativeBounds(int width, int height, SkIRect* devResult,
                                        bool* isIntersectionOfRects = nullptr) const = 0;
-    virtual bool apply(GrContext*,
-                       GrDrawContext*,
-                       const SkRect* devBounds,
-                       bool useHWAA,
-                       bool hasUserStencilSettings,
+    virtual bool apply(GrContext*, GrDrawContext*, bool useHWAA, bool hasUserStencilSettings,
                        GrAppliedClip* out) const = 0;
 
     virtual ~GrClip() {}
 
     /**
      * This is the maximum distance that a draw may extend beyond a clip's boundary and still count
      * count as "on the other side". We leave some slack because floating point rounding error is
      * likely to blame. The rationale for 1e-3 is that in the coverage case (and barring unexpected
      * rounding), as long as coverage stays within 0.5 * 1/256 of its intended value it shouldn't
      * have any effect on the final pixel values.
@@ skipping 64 matching lines @@
 };
 
 /**
  * Specialized implementation for no clip.
  */
 class GrNoClip final : public GrClip {
 private:
     bool quickContains(const SkRect&) const final { return true; }
     void getConservativeBounds(int width, int height, SkIRect* devResult,
                                bool* isIntersectionOfRects) const final;
-    bool apply(GrContext*,
-               GrDrawContext*,
-               const SkRect* /* devBounds */,
-               bool /* useHWAA */,
-               bool /* hasUserStencilSettings */,
-               GrAppliedClip* /* out */) const final { return true; }
+    bool apply(GrContext*, GrDrawContext*, bool, bool, GrAppliedClip*) const final { return true; }
 };
 
 /**
  * GrFixedClip is a clip that can be represented by fixed-function hardware. It never modifies the
  * stencil buffer itself, but can be configured to use whatever clip is already there.
  */
 class GrFixedClip final : public GrClip {
 public:
-    GrFixedClip() : fDeviceBounds(SkRect::MakeLargest()), fHasStencilClip(false) {}
+    GrFixedClip() : fHasStencilClip(false) {}
     GrFixedClip(const SkIRect& scissorRect)
         : fScissorState(scissorRect)
-        , fDeviceBounds(SkRect::Make(scissorRect))
         , fHasStencilClip(false) {}
 
     void reset() {
         fScissorState.setDisabled();
-        fDeviceBounds.setLargest();
         fHasStencilClip = false;
     }
 
     void reset(const SkIRect& scissorRect) {
         fScissorState.set(scissorRect);
-        fDeviceBounds = SkRect::Make(scissorRect);
         fHasStencilClip = false;
     }
 
-    /**
-     * Enables stenciling. The stencil bounds is the device space bounds where the stencil test
-     * may pass.
-     */
-    void enableStencilClip(const SkRect& stencilBounds) {
-        fHasStencilClip = true;
-        fDeviceBounds = stencilBounds;
-        if (fScissorState.enabled()) {
-            const SkIRect& s = fScissorState.rect();
-            fDeviceBounds.fLeft   = SkTMax(fDeviceBounds.fLeft,   SkIntToScalar(s.fLeft));
-            fDeviceBounds.fTop    = SkTMax(fDeviceBounds.fTop,    SkIntToScalar(s.fTop));
-            fDeviceBounds.fRight  = SkTMin(fDeviceBounds.fRight,  SkIntToScalar(s.fRight));
-            fDeviceBounds.fBottom = SkTMin(fDeviceBounds.fBottom, SkIntToScalar(s.fBottom));
-        }
-    }
-
-    void disableStencilClip() {
-        fHasStencilClip = false;
-        if (fScissorState.enabled()) {
-            fDeviceBounds = SkRect::Make(fScissorState.rect());
-        } else {
-            fDeviceBounds.setLargest();
-        }
-    }
-
-    const GrScissorState& scissorState() const { return fScissorState; }
-    bool hasStencilClip() const { return fHasStencilClip; }
+    void enableStencilClip() { fHasStencilClip = true; }
+    void disableStencilClip() { fHasStencilClip = false; }
 
     bool quickContains(const SkRect&) const final;
     void getConservativeBounds(int width, int height, SkIRect* devResult,
                                bool* isIntersectionOfRects) const final;
 
 private:
-    bool apply(GrContext*,
-               GrDrawContext*,
-               const SkRect* devBounds,
-               bool useHWAA,
-               bool hasUserStencilSettings,
+    bool apply(GrContext*, GrDrawContext*, bool useHWAA, bool hasUserStencilSettings,
                GrAppliedClip* out) const final;
 
     GrScissorState   fScissorState;
-    SkRect           fDeviceBounds;

[csmartdalton, 2016/08/15 16:05:25]

Here we can eventually store a simple SkRect that just tells us the bounding box
of the scissor. All intersect logic can happen once it's added to GrAppliedClip.

     bool             fHasStencilClip;
 };
 
 #endif