Allow GrReducedClip to take non-integer query bounds

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
 
@@ skipping 95 matching lines @@
                                        bool* isIntersectionOfRects = nullptr) const = 0;
     virtual bool apply(GrContext*,
                        GrDrawContext*,
                        const SkRect* devBounds,
                        bool useHWAA,
                        bool hasUserStencilSettings,
                        GrAppliedClip* out) const = 0;
 
     virtual ~GrClip() {}
 
-protected:
     /**
-     * Returns true if a clip can safely disable its scissor test for a particular draw.
+     * 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.
      */
-    static bool CanIgnoreScissor(const SkIRect& scissorRect, const SkRect& drawBounds) {
-        // This is the maximum distance that a draw may extend beyond a clip's scissor and still
-        // count as inside. We use a sloppy compare because the draw may have chosen its bounds in a
-        // different coord system. The rationale for 1e-3 is that in the coverage case (and barring
-        // unexpected rounding), as long as coverage stays below 0.5 * 1/256 we ought to be OK.
-        constexpr SkScalar fuzz = 1e-3f;
-        SkASSERT(!scissorRect.isEmpty());
-        SkASSERT(!drawBounds.isEmpty());
-        return scissorRect.fLeft <= drawBounds.fLeft + fuzz &&
-               scissorRect.fTop <= drawBounds.fTop + fuzz &&
-               scissorRect.fRight >= drawBounds.fRight - fuzz &&
-               scissorRect.fBottom >= drawBounds.fBottom - fuzz;
+    constexpr static SkScalar kClipBoundsFuzz = 1e-3f;

[bsalomon, 2016/07/19 13:33:12]

Can we call this tolerance or "tol" rather than fuzz? Just more consistent with
other similar constants.

[csmartdalton, 2016/07/19 15:59:00]

Done.

+
+    /**
+     * Returns true if the given query bounds count as entirely inside the clip.
+     *
+     * @param innerClipBounds   device-space rect contained by the clip (SkRect or SkIRect).
+     * @param queryBounds       device-space bounds of the query region.
+     */
+    template<typename TRect> constexpr static bool IsInsideClip(const TRect& innerClipBounds,
+                                                                const SkRect& queryBounds) {
+        return innerClipBounds.fRight - innerClipBounds.fLeft >= kClipBoundsFuzz &&
+               innerClipBounds.fBottom - innerClipBounds.fTop >= kClipBoundsFuzz &&
+               innerClipBounds.fLeft <= queryBounds.fLeft + kClipBoundsFuzz &&
+               innerClipBounds.fTop <= queryBounds.fTop + kClipBoundsFuzz &&
+               innerClipBounds.fRight >= queryBounds.fRight - kClipBoundsFuzz &&
+               innerClipBounds.fBottom >= queryBounds.fBottom - kClipBoundsFuzz;
     }
 
-    friend class GrClipMaskManager;
+    /**
+     * Returns true if the given query bounds count as entirely outside the clip.
+     *
+     * @param outerClipBounds   device-space rect that contains the clip (SkRect or SkIRect).
+     * @param queryBounds       device-space bounds of the query region.
+     */
+    template<typename TRect> constexpr static bool IsOutsideClip(const TRect& outerClipBounds,
+                                                                 const SkRect& queryBounds) {
+        return outerClipBounds.fRight - outerClipBounds.fLeft < kClipBoundsFuzz ||
+               outerClipBounds.fBottom - outerClipBounds.fTop < kClipBoundsFuzz ||
+               outerClipBounds.fLeft > queryBounds.fRight - kClipBoundsFuzz ||
+               outerClipBounds.fTop > queryBounds.fBottom - kClipBoundsFuzz ||
+               outerClipBounds.fRight < queryBounds.fLeft + kClipBoundsFuzz ||
+               outerClipBounds.fBottom < queryBounds.fTop + kClipBoundsFuzz;
+    }
+
+    /**
+     * Returns the minimal integer rect that counts as containing a given set of bounds.
+     */
+    static SkIRect GetPixelIBounds(const SkRect& bounds) {
+        return SkIRect::MakeLTRB(SkScalarFloorToInt(bounds.fLeft + kClipBoundsFuzz),
+                                 SkScalarFloorToInt(bounds.fTop + kClipBoundsFuzz),
+                                 SkScalarCeilToInt(bounds.fRight - kClipBoundsFuzz),
+                                 SkScalarCeilToInt(bounds.fBottom - kClipBoundsFuzz));
+    }
+
+    /**
+     * Returns the minimal pixel-aligned rect that counts as containing a given set of bounds.
+     */
+    static SkRect GetPixelBounds(const SkRect& bounds) {
+        return SkRect::MakeLTRB(SkScalarFloorToScalar(bounds.fLeft + kClipBoundsFuzz),
+                                SkScalarFloorToScalar(bounds.fTop + kClipBoundsFuzz),
+                                SkScalarCeilToScalar(bounds.fRight - kClipBoundsFuzz),
+                                SkScalarCeilToScalar(bounds.fBottom - kClipBoundsFuzz));
+    }
+
+    /**
+     * Returns true if the given rect counts as aligned with pixel boundaries.
+     */
+    static bool IsPixelAligned(const SkRect& rect) {
+        return SkScalarAbs(SkScalarRoundToScalar(rect.fLeft) - rect.fLeft) <= kClipBoundsFuzz &&
+               SkScalarAbs(SkScalarRoundToScalar(rect.fTop) - rect.fTop) <= kClipBoundsFuzz &&
+               SkScalarAbs(SkScalarRoundToScalar(rect.fRight) - rect.fRight) <= kClipBoundsFuzz &&
+               SkScalarAbs(SkScalarRoundToScalar(rect.fBottom) - rect.fBottom) <= kClipBoundsFuzz;
+    }
 };
 
 /**
  * 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;
@@ skipping 101 matching lines @@
                bool useHWAA,
                bool hasUserStencilSettings,
                GrAppliedClip* out) const final;
 
 private:
     SkIPoint                          fOrigin;
     SkAutoTUnref<const SkClipStack>   fStack;
 };
 
 #endif