Optimized implementation of quickReject()

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 548 matching lines @@
     /** Return true if the horizontal band specified by top and bottom is
         completely clipped out. This is a conservative calculation, meaning
         that it is possible that if the method returns false, the band may still
         in fact be clipped out, but the converse is not true. If this method
         returns true, then the band is guaranteed to be clipped out.
         @param top  The top of the horizontal band to compare with the clip
         @param bottom The bottom of the horizontal and to compare with the clip
         @return true if the horizontal band is completely clipped out (i.e. does
                      not intersect the current clip)
     */
-    bool quickRejectY(SkScalar top, SkScalar bottom) const {
-        SkASSERT(top <= bottom);
-
-#ifndef SK_WILL_NEVER_DRAW_PERSPECTIVE_TEXT
-        // TODO: add a hasPerspective method similar to getLocalClipBounds. This
-        // would cache the SkMatrix::hasPerspective result. Alternatively, have
-        // the MC stack just set a hasPerspective boolean as it is updated.
-        if (this->getTotalMatrix().hasPerspective()) {
-            // TODO: consider implementing some half-plane test between the
-            // two Y planes and the device-bounds (i.e., project the top and
-            // bottom Y planes and then determine if the clip bounds is completely
-            // outside either one).
-            return false;
-        }
-#endif
-
-        const SkRect& clipR = this->getLocalClipBounds();
-        // In the case where the clip is empty and we are provided with a
-        // negative top and positive bottom parameter then this test will return
-        // false even though it will be clipped. We have chosen to exclude that
-        // check as it is rare and would result double the comparisons.
-        return top >= clipR.fBottom || bottom <= clipR.fTop;
-    }
+    bool quickRejectY(SkScalar top, SkScalar bottom) const;
 
     /** Return the bounds of the current clip (in local coordinates) in the
         bounds parameter, and return true if it is non-empty. This can be useful
         in a way similar to quickReject, in that it tells you that drawing
         outside of these bounds will be clipped out.
     */
     virtual bool getClipBounds(SkRect* bounds) const;
 
     /** Return the bounds of the current clip, in device coordinates; returns
         true if non-empty. Maybe faster than getting the clip explicitly and
@@ skipping 1030 matching lines @@
      *  paint (or default if null) would overwrite the entire root device of the canvas
      *  (i.e. the canvas' surface if it had one).
      */
     bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*, ShaderOverrideOpacity) const;
 
     /**
      *  Returns true if the paint's imagefilter can be invoked directly, without needed a layer.
      */
     bool canDrawBitmapAsSprite(SkScalar x, SkScalar y, int w, int h, const SkPaint&);
 
-    /*  These maintain a cache of the clip bounds in local coordinates,
-        (converted to 2s-compliment if floats are slow).
+
+    /**
+     *  Keep track of the device clip bounds and if the matrix is scale-translate.  This allows
+     *  us to do a fast quick reject in the common case.
      */
-    mutable SkRect fCachedLocalClipBounds;
-    mutable bool   fCachedLocalClipBoundsDirty;
+    bool   fIsScaleTranslate;
+    SkRect fDeviceClipBounds;
+
     bool fAllowSoftClip;
     bool fAllowSimplifyClip;
     const bool fConservativeRasterClip;
 
-    const SkRect& getLocalClipBounds() const {
-        if (fCachedLocalClipBoundsDirty) {
-            if (!this->getClipBounds(&fCachedLocalClipBounds)) {
-                fCachedLocalClipBounds.setEmpty();
-            }
-            fCachedLocalClipBoundsDirty = false;
-        }
-        return fCachedLocalClipBounds;
-    }
-
     class AutoValidateClip : ::SkNoncopyable {
     public:
         explicit AutoValidateClip(SkCanvas* canvas) : fCanvas(canvas) {
             fCanvas->validateClip();
         }
         ~AutoValidateClip() { fCanvas->validateClip(); }
 
     private:
         const SkCanvas* fCanvas;
     };
@@ skipping 46 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif