Implement computeFastBounds() for SkImageFilter. This allows for the correct culling of primitives …

src/core/SkCanvas.cpp

 
 /*
  * Copyright 2008 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.
  */
 
 
 #include "SkCanvas.h"
@@ skipping 317 matching lines @@
     SkBool8         fSkipEmptyClips;
 
     typedef SkDraw INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
 class AutoDrawLooper {
 public:
     AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint,
-                   bool skipLayerForImageFilter = false) : fOrigPaint(paint) {
+                   bool skipLayerForImageFilter = false,
+                   const SkRect* bounds = NULL) : fOrigPaint(paint) {
         fCanvas = canvas;
         fLooper = paint.getLooper();
         fFilter = canvas->getDrawFilter();
         fPaint = NULL;
         fSaveCount = canvas->getSaveCount();
         fDoClearImageFilter = false;
         fDone = false;
 
         if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
             SkPaint tmp;
             tmp.setImageFilter(fOrigPaint.getImageFilter());
-            // it would be nice if we had a guess at the bounds, instead of null
-            (void)canvas->internalSaveLayer(NULL, &tmp,
+            (void)canvas->internalSaveLayer(bounds, &tmp,
                                     SkCanvas::kARGB_ClipLayer_SaveFlag, true);
             // we'll clear the imageFilter for the actual draws in next(), so
             // it will only be applied during the restore().
             fDoClearImageFilter = true;
         }
 
         if (fLooper) {
             fLooper->init(canvas);
             fIsSimple = false;
         } else {
@@ skipping 102 matching lines @@
 
 ////////// macros to place around the internal draw calls //////////////////
 
 #define LOOPER_BEGIN_DRAWDEVICE(paint, type)                        \
     this->predrawNotify();                                          \
     AutoDrawLooper  looper(this, paint, true);                      \
     while (looper.next(type)) {                                     \
         SkAutoBounderCommit ac(fBounder);                           \
         SkDrawIter          iter(this);
 
-#define LOOPER_BEGIN(paint, type)                                   \
+#define LOOPER_BEGIN(paint, type, bounds)                           \
     this->predrawNotify();                                          \
-    AutoDrawLooper  looper(this, paint);                            \
+    AutoDrawLooper  looper(this, paint, false, bounds);             \
     while (looper.next(type)) {                                     \
         SkAutoBounderCommit ac(fBounder);                           \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkCanvas::init(SkBaseDevice* device) {
     fBounder = NULL;
@@ skipping 478 matching lines @@
     }
 
     SkLazyPaint lazy;
     if (NULL == paint) {
         paint = lazy.init();
     }
 
     SkDEBUGCODE(bitmap.validate();)
     CHECK_LOCKCOUNT_BALANCE(bitmap);
 
-    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
+    SkRect storage;
+    const SkRect* bounds = NULL;
+    if (paint && paint->canComputeFastBounds()) {
+        bitmap.getBounds(&storage);
+        matrix.mapRect(&storage);
+        bounds = &paint->computeFastBounds(storage, &storage);
+    }
+
+    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawBitmap(iter, bitmap, matrix, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::internalDrawDevice(SkBaseDevice* srcDev, int x, int y,
                                   const SkPaint* paint) {
@@ skipping 579 matching lines @@
     }
 }
 
 void SkCanvas::drawPaint(const SkPaint& paint) {
     this->internalDrawPaint(paint);
 }
 
 void SkCanvas::internalDrawPaint(const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kPaint_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kPaint_Type, NULL)
 
     while (iter.next()) {
         iter.fDevice->drawPaint(iter, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
                           const SkPaint& paint) {
     if ((long)count <= 0) {
         return;
     }
 
     CHECK_SHADER_NOSETCONTEXT(paint);
 
+    SkRect r, storage;
+    const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
-        SkRect r;
         // special-case 2 points (common for drawing a single line)
         if (2 == count) {
             r.set(pts[0], pts[1]);
         } else {
             r.set(pts, SkToInt(count));
         }
-        SkRect storage;
-        if (this->quickReject(paint.computeFastStrokeBounds(r, &storage))) {
+        bounds = &paint.computeFastStrokeBounds(r, &storage);
+        if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     SkASSERT(pts != NULL);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kPoint_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kPoint_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawPoints(iter, mode, count, pts, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
+    SkRect storage;
+    const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
-        SkRect storage;
-        if (this->quickReject(paint.computeFastBounds(r, &storage))) {
+        bounds = &paint.computeFastBounds(r, &storage);
+        if (this->quickReject(*bounds)) {
             return;
         }
     }
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kRect_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kRect_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawRect(iter, r, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
+    SkRect storage;
+    const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
-        SkRect storage;
-        if (this->quickReject(paint.computeFastBounds(oval, &storage))) {
+        bounds = &paint.computeFastBounds(oval, &storage);
+        if (this->quickReject(*bounds)) {
             return;
         }
     }
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kOval_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kOval_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawOval(iter, oval, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
+    SkRect storage;
+    const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
-        SkRect storage;
-        if (this->quickReject(paint.computeFastBounds(rrect.getBounds(), &storage))) {
+        bounds = &paint.computeFastBounds(rrect.getBounds(), &storage);
+        if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     if (rrect.isRect()) {
         // call the non-virtual version
         this->SkCanvas::drawRect(rrect.getBounds(), paint);
         return;
     } else if (rrect.isOval()) {
         // call the non-virtual version
         this->SkCanvas::drawOval(rrect.getBounds(), paint);
         return;
     }
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kRRect_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kRRect_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawRRect(iter, rrect, looper.paint());
     }
 
     LOOPER_END
 }
 
 
 void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
     if (!path.isFinite()) {
         return;
     }
 
+    SkRect storage;
+    const SkRect* bounds = NULL;
     if (!path.isInverseFillType() && paint.canComputeFastBounds()) {
-        SkRect storage;
-        const SkRect& bounds = path.getBounds();
-        if (this->quickReject(paint.computeFastBounds(bounds, &storage))) {
+        const SkRect& pathBounds = path.getBounds();
+        bounds = &paint.computeFastBounds(pathBounds, &storage);
+        if (this->quickReject(*bounds)) {
             return;
         }
     }
     if (path.isEmpty()) {
         if (path.isInverseFillType()) {
             this->internalDrawPaint(paint);
         }
         return;
     }
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawPath(iter, path, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
                           const SkPaint* paint) {
@@ skipping 21 matching lines @@
 // this one is non-virtual, so it can be called safely by other canvas apis
 void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                                       const SkRect& dst, const SkPaint* paint,
                                       DrawBitmapRectFlags flags) {
     if (bitmap.width() == 0 || bitmap.height() == 0 || dst.isEmpty()) {
         return;
     }
 
     CHECK_LOCKCOUNT_BALANCE(bitmap);
 
+    SkRect storage;
+    const SkRect* bounds = &dst;
     if (NULL == paint || paint->canComputeFastBounds()) {
-        SkRect storage;
-        const SkRect* bounds = &dst;
         if (paint) {
             bounds = &paint->computeFastBounds(dst, &storage);
         }
         if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     SkLazyPaint lazy;
     if (NULL == paint) {
         paint = lazy.init();
     }
 
-    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
+    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawBitmapRect(iter, bitmap, src, dst, looper.paint(), flags);
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
                                     const SkRect& dst, const SkPaint* paint,
@@ skipping 173 matching lines @@
             r.fBottom = offset + height;
             DrawRect(draw, paint, r, textSize);
         }
     }
 }
 
 void SkCanvas::drawText(const void* text, size_t byteLength,
                         SkScalar x, SkScalar y, const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
 
     while (iter.next()) {
         SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
         iter.fDevice->drawText(iter, text, byteLength, x, y, dfp.paint());
         DrawTextDecorations(iter, dfp.paint(),
                             static_cast<const char*>(text), byteLength, x, y);
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPosText(const void* text, size_t byteLength,
                            const SkPoint pos[], const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
 
     while (iter.next()) {
         SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
         iter.fDevice->drawPosText(iter, text, byteLength, &pos->fX, 0, 2,
                                   dfp.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPosTextH(const void* text, size_t byteLength,
                             const SkScalar xpos[], SkScalar constY,
                             const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
 
     while (iter.next()) {
         SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
         iter.fDevice->drawPosText(iter, text, byteLength, xpos, constY, 1,
                                   dfp.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawTextOnPath(const void* text, size_t byteLength,
                               const SkPath& path, const SkMatrix* matrix,
                               const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, NULL)
 
     while (iter.next()) {
         iter.fDevice->drawTextOnPath(iter, text, byteLength, path,
                                      matrix, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawVertices(VertexMode vmode, int vertexCount,
                             const SkPoint verts[], const SkPoint texs[],
                             const SkColor colors[], SkXfermode* xmode,
                             const uint16_t indices[], int indexCount,
                             const SkPaint& paint) {
     CHECK_SHADER_NOSETCONTEXT(paint);
 
-    LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type)
+    LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, NULL)
 
     while (iter.next()) {
         iter.fDevice->drawVertices(iter, vmode, vertexCount, verts, texs,
                                    colors, xmode, indices, indexCount,
                                    looper.paint());
     }
 
     LOOPER_END
 }
 
@@ skipping 154 matching lines @@
     return *paint;
 }
 
 const SkRegion& SkCanvas::LayerIter::clip() const { return fImpl->getClip(); }
 int SkCanvas::LayerIter::x() const { return fImpl->getX(); }
 int SkCanvas::LayerIter::y() const { return fImpl->getY(); }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCanvas::ClipVisitor::~ClipVisitor() { }