clipShader -- raster implementation

1. pass shader+op down to device
2. bitmapdevice pass it down to rasterclip
3. rasterclip only ever stores at most one shader
   - if there is a ctm, fold that into (another) shader
   - if the op is difference, invert the sense of alpha
   - if there was a previous shader, compose with it
4. pass through to rasterpipelineblitter
5. it prepends the colorPipeline with the clipShader, and stashes its
   results in a buffer (fClipShaderBuffer)
6. in each blit, scale/lerp from the buffer before storing the result

Change-Id: I07c7a8a20b9ae95cdcc9954237d115e63819f7c1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/275798
Commit-Queue: Mike Reed <[email protected]>
Reviewed-by: Mike Klein <[email protected]>
Reviewed-by: Florin Malita <[email protected]>

Author: reed-at-google

gm/complexclip.cpp

@@ -20,6 +20,7 @@
 #include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 #include "src/core/SkClipOpPriv.h"
+#include "tools/Resources.h"
 #include "tools/ToolUtils.h"
 
 #include <string.h>
@@ -209,3 +210,39 @@ DEF_GM(return new ComplexClipGM(true, false, true);)
 DEF_GM(return new ComplexClipGM(true, true, false);)
 DEF_GM(return new ComplexClipGM(true, true, true);)
 }
+
+DEF_SIMPLE_GM(clip_shader, canvas, 840, 650) {
+    auto img = GetResourceAsImage("images/yellow_rose.png");
+    auto sh = img->makeShader();
+
+    SkRect r = SkRect::MakeIWH(img->width(), img->height());
+    SkPaint p;
+
+    canvas->translate(10, 10);
+    canvas->drawImage(img, 0, 0, nullptr);
+
+    canvas->save();
+    canvas->translate(img->width() + 10, 0);
+    canvas->clipShader(sh, SkClipOp::kIntersect);
+    p.setColor(SK_ColorRED);
+    canvas->drawRect(r, p);
+    canvas->restore();
+
+    canvas->save();
+    canvas->translate(0, img->height() + 10);
+    canvas->clipShader(sh, SkClipOp::kDifference);
+    p.setColor(SK_ColorGREEN);
+    canvas->drawRect(r, p);
+    canvas->restore();
+
+    canvas->save();
+    canvas->translate(img->width() + 10, img->height() + 10);
+    canvas->clipShader(sh, SkClipOp::kIntersect);
+    canvas->save();
+    SkMatrix lm = SkMatrix::MakeScale(1.0f / 5);
+    canvas->clipShader(img->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &lm));
+    canvas->drawImage(img, 0, 0, nullptr);
+
+    canvas->restore();
+    canvas->restore();
+}

include/core/SkCanvas.h

@@ -1032,6 +1032,8 @@ class SK_API SkCanvas {
         this->clipPath(path, SkClipOp::kIntersect, doAntiAlias);
     }
 
+    void clipShader(sk_sp<SkShader>, SkClipOp = SkClipOp::kIntersect);
+
     /** Replaces clip with the intersection or difference of clip and SkRegion deviceRgn.
         Resulting clip is aliased; pixels are fully contained by the clip.
         deviceRgn is unaffected by SkMatrix.
@@ -2644,6 +2646,7 @@ class SK_API SkCanvas {
     virtual void onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle);
     virtual void onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle);
     virtual void onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle);
+    virtual void onClipShader(sk_sp<SkShader>, SkClipOp);
     virtual void onClipRegion(const SkRegion& deviceRgn, SkClipOp op);
 
     virtual void onDiscard();

include/utils/SkLuaCanvas.h

@@ -61,6 +61,7 @@ class SkLuaCanvas : public SkCanvas {
     void onClipRect(const SkRect&, SkClipOp, ClipEdgeStyle) override;
     void onClipRRect(const SkRRect&, SkClipOp, ClipEdgeStyle) override;
     void onClipPath(const SkPath&, SkClipOp, ClipEdgeStyle) override;
+    void onClipShader(sk_sp<SkShader>, SkClipOp) override;
     void onClipRegion(const SkRegion&, SkClipOp) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;

include/utils/SkNWayCanvas.h

@@ -78,6 +78,7 @@ class SK_API SkNWayCanvas : public SkCanvasVirtualEnforcer<SkNoDrawCanvas> {
     void onClipRect(const SkRect&, SkClipOp, ClipEdgeStyle) override;
     void onClipRRect(const SkRRect&, SkClipOp, ClipEdgeStyle) override;
     void onClipPath(const SkPath&, SkClipOp, ClipEdgeStyle) override;
+    void onClipShader(sk_sp<SkShader>, SkClipOp) override;
     void onClipRegion(const SkRegion&, SkClipOp) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;

src/core/SkAutoBlitterChoose.h

@@ -12,6 +12,7 @@
 #include "src/core/SkArenaAlloc.h"
 #include "src/core/SkBlitter.h"
 #include "src/core/SkDraw.h"
+#include "src/core/SkRasterClip.h"
 
 class SkMatrix;
 class SkPaint;
@@ -34,12 +35,13 @@ class SkAutoBlitterChoose : SkNoncopyable {
         if (!matrix) {
             matrix = draw.fMatrix;
         }
-        fBlitter = SkBlitter::Choose(draw.fDst, *matrix, paint, &fAlloc, drawCoverage);
+        fBlitter = SkBlitter::Choose(draw.fDst, *matrix, paint, &fAlloc, drawCoverage,
+                                     draw.fRC->clipShader());
 
         if (draw.fCoverage) {
             // hmm, why can't choose ignore the paint if drawCoverage is true?
             SkBlitter* coverageBlitter = SkBlitter::Choose(*draw.fCoverage, *matrix, SkPaint(),
-                                                           &fAlloc, true);
+                                                           &fAlloc, true, draw.fRC->clipShader());
             fBlitter = fAlloc.make<SkPairBlitter>(fBlitter, coverageBlitter);
         }
         return fBlitter;

src/core/SkBitmapDevice.cpp

@@ -757,6 +757,10 @@ void SkBitmapDevice::onClipPath(const SkPath& path, SkClipOp op, bool aa) {
     fRCStack.clipPath(this->localToDevice(), path, op, aa);
 }
 
+void SkBitmapDevice::onClipShader(sk_sp<SkShader> sh, SkClipOp op) {
+    fRCStack.clipShader(this->localToDevice(), std::move(sh), op);
+}
+
 void SkBitmapDevice::onClipRegion(const SkRegion& rgn, SkClipOp op) {
     SkIPoint origin = this->getOrigin();
     SkRegion tmp;

src/core/SkBitmapDevice.h

@@ -125,6 +125,7 @@ class SkBitmapDevice : public SkBaseDevice {
     void onClipRect(const SkRect& rect, SkClipOp, bool aa) override;
     void onClipRRect(const SkRRect& rrect, SkClipOp, bool aa) override;
     void onClipPath(const SkPath& path, SkClipOp, bool aa) override;
+    void onClipShader(sk_sp<SkShader>, SkClipOp) override;
     void onClipRegion(const SkRegion& deviceRgn, SkClipOp) override;
     void onSetDeviceClipRestriction(SkIRect* mutableClipRestriction) override;
     bool onClipIsAA() const override;

src/core/SkBlitter.cpp

@@ -687,7 +687,8 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
                              SkArenaAlloc* alloc,
-                             bool drawCoverage) {
+                             bool drawCoverage,
+                             sk_sp<SkShader> clipShader) {
     SkASSERT(alloc);
 
     if (kUnknown_SkColorType == device.colorType()) {
@@ -739,7 +740,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
         paint.writable()->setDither(false);
     }
 
-    bool try_skvm_blitter = gUseSkVMBlitter;
+    bool try_skvm_blitter = gUseSkVMBlitter && !clipShader;
 #if defined(SK_USE_SKVM_BLITTER)
     try_skvm_blitter = true;
 #endif
@@ -750,8 +751,8 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     }
 
     // We'll end here for many interesting cases: color spaces, color filters, most color types.
-    if (UseRasterPipelineBlitter(device, *paint, matrix)) {
-        auto blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc);
+    if (UseRasterPipelineBlitter(device, *paint, matrix) || clipShader) {
+        auto blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc, clipShader);
         SkASSERT(blitter);
         return blitter;
     }
@@ -772,7 +773,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
 
         // Creating the context isn't always possible... we'll just fall back to raster pipeline.
         if (!shaderContext) {
-            auto blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc);
+            auto blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc, clipShader);
             SkASSERT(blitter);
             return blitter;
         }
@@ -794,7 +795,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
             if (shaderContext && SkRGB565_Shader_Blitter::Supports(device, *paint)) {
                 return alloc->make<SkRGB565_Shader_Blitter>(device, *paint, shaderContext);
             } else {
-                return SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc);
+                return SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc, clipShader);
             }
 
         default:

src/core/SkBlitter.h

@@ -143,13 +143,14 @@ class SkBlitter {
                              const SkMatrix& matrix,
                              const SkPaint& paint,
                              SkArenaAlloc*,
-                             bool drawCoverage = false);
+                             bool drawCoverage,
+                             sk_sp<SkShader> clipShader);
 
     static SkBlitter* ChooseSprite(const SkPixmap& dst,
                                    const SkPaint&,
                                    const SkPixmap& src,
                                    int left, int top,
-                                   SkArenaAlloc*);
+                                   SkArenaAlloc*, sk_sp<SkShader> clipShader);
     ///@}
 
     static bool UseRasterPipelineBlitter(const SkPixmap&, const SkPaint&, const SkMatrix&);

src/core/SkBlitter_Sprite.cpp

@@ -98,11 +98,13 @@ class SkSpriteBlitter_Memcpy final : public SkSpriteBlitter {
 
 class SkRasterPipelineSpriteBlitter : public SkSpriteBlitter {
 public:
-    SkRasterPipelineSpriteBlitter(const SkPixmap& src, SkArenaAlloc* alloc)
+    SkRasterPipelineSpriteBlitter(const SkPixmap& src, SkArenaAlloc* alloc,
+                                  sk_sp<SkShader> clipShader)
         : INHERITED(src)
         , fAlloc(alloc)
         , fBlitter(nullptr)
         , fSrcPtr{nullptr, 0}
+        , fClipShader(std::move(clipShader))
     {}
 
     void setup(const SkPixmap& dst, int left, int top, const SkPaint& paint) override {
@@ -137,7 +139,7 @@ class SkRasterPipelineSpriteBlitter : public SkSpriteBlitter {
         }
 
         bool is_opaque = fSource.isOpaque() && fPaintColor.fA == 1.0f;
-        fBlitter = SkCreateRasterPipelineBlitter(fDst, paint, p, is_opaque, fAlloc);
+        fBlitter = SkCreateRasterPipelineBlitter(fDst, paint, p, is_opaque, fAlloc, fClipShader);
     }
 
     void blitRect(int x, int y, int width, int height) override {
@@ -159,14 +161,16 @@ class SkRasterPipelineSpriteBlitter : public SkSpriteBlitter {
     SkBlitter*                 fBlitter;
     SkRasterPipeline_MemoryCtx fSrcPtr;
     SkColor4f                  fPaintColor;
+    sk_sp<SkShader>            fClipShader;
 
     typedef SkSpriteBlitter INHERITED;
 };
 
 // returning null means the caller will call SkBlitter::Choose() and
 // have wrapped the source bitmap inside a shader
 SkBlitter* SkBlitter::ChooseSprite(const SkPixmap& dst, const SkPaint& paint,
-        const SkPixmap& source, int left, int top, SkArenaAlloc* allocator) {
+                                   const SkPixmap& source, int left, int top,
+                                   SkArenaAlloc* alloc, sk_sp<SkShader> clipShader) {
     /*  We currently ignore antialiasing and filtertype, meaning we will take our
         special blitters regardless of these settings. Ignoring filtertype seems fine
         since by definition there is no scale in the matrix. Ignoring antialiasing is
@@ -176,7 +180,7 @@ SkBlitter* SkBlitter::ChooseSprite(const SkPixmap& dst, const SkPaint& paint,
         paint and return null if it is set, forcing the client to take the slow shader case
         (which does respect soft edges).
     */
-    SkASSERT(allocator != nullptr);
+    SkASSERT(alloc != nullptr);
 
     // TODO: in principle SkRasterPipelineSpriteBlitter could be made to handle this.
     if (source.alphaType() == kUnpremul_SkAlphaType) {
@@ -185,28 +189,28 @@ SkBlitter* SkBlitter::ChooseSprite(const SkPixmap& dst, const SkPaint& paint,
 
     SkSpriteBlitter* blitter = nullptr;
 
-    if (0 == SkColorSpaceXformSteps(source,dst).flags.mask()) {
+    if (0 == SkColorSpaceXformSteps(source,dst).flags.mask() && !clipShader) {
         if (!blitter && SkSpriteBlitter_Memcpy::Supports(dst, source, paint)) {
-            blitter = allocator->make<SkSpriteBlitter_Memcpy>(source);
+            blitter = alloc->make<SkSpriteBlitter_Memcpy>(source);
         }
         if (!blitter) {
             switch (dst.colorType()) {
                 case kN32_SkColorType:
-                    blitter = SkSpriteBlitter::ChooseL32(source, paint, allocator);
+                    blitter = SkSpriteBlitter::ChooseL32(source, paint, alloc);
                     break;
                 case kRGB_565_SkColorType:
-                    blitter = SkSpriteBlitter::ChooseL565(source, paint, allocator);
+                    blitter = SkSpriteBlitter::ChooseL565(source, paint, alloc);
                     break;
                 case kAlpha_8_SkColorType:
-                    blitter = SkSpriteBlitter::ChooseLA8(source, paint, allocator);
+                    blitter = SkSpriteBlitter::ChooseLA8(source, paint, alloc);
                     break;
                 default:
                     break;
             }
         }
     }
     if (!blitter && !paint.getMaskFilter()) {
-        blitter = allocator->make<SkRasterPipelineSpriteBlitter>(source, allocator);
+        blitter = alloc->make<SkRasterPipelineSpriteBlitter>(source, alloc, clipShader);
     }
 
     if (blitter) {

src/core/SkCanvas.cpp

@@ -1649,6 +1649,20 @@ void SkCanvas::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeSty
     fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
 }
 
+void SkCanvas::clipShader(sk_sp<SkShader> sh, SkClipOp op) {
+    if (sh) {
+        this->onClipShader(std::move(sh), op);
+    }
+}
+
+void SkCanvas::onClipShader(sk_sp<SkShader> sh, SkClipOp op) {
+    AutoValidateClip avc(this);
+
+    FOR_EACH_TOP_DEVICE(device->clipShader(sh, op));
+
+    // we don't know how to mutate our conservative bounds, so we don't
+}
+
 void SkCanvas::clipRegion(const SkRegion& rgn, SkClipOp op) {
     this->checkForDeferredSave();
     this->onClipRegion(rgn, op);

src/core/SkCoreBlitters.h

@@ -166,13 +166,13 @@ class SkRGB565_Shader_Blitter : public SkShaderBlitter {
 
 // Neither of these ever returns nullptr, but this first factory may return a SkNullBlitter.
 SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap&, const SkPaint&, const SkMatrix& ctm,
-                                         SkArenaAlloc*);
+                                         SkArenaAlloc*, sk_sp<SkShader> clipShader);
 // Use this if you've pre-baked a shader pipeline, including modulating with paint alpha.
 // This factory never returns an SkNullBlitter.
 SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap&, const SkPaint&,
                                          const SkRasterPipeline& shaderPipeline,
                                          bool shader_is_opaque,
-                                         SkArenaAlloc*);
+                                         SkArenaAlloc*, sk_sp<SkShader> clipShader);
 
 SkBlitter* SkCreateSkVMBlitter(const SkPixmap&, const SkPaint&, const SkMatrix& ctm, SkArenaAlloc*);
 

src/core/SkDevice.h

@@ -12,6 +12,7 @@
 #include "include/core/SkColor.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkRegion.h"
+#include "include/core/SkShader.h"
 #include "include/core/SkSurfaceProps.h"
 #include "include/private/SkNoncopyable.h"
 
@@ -150,6 +151,9 @@ class SkBaseDevice : public SkRefCnt {
     void clipPath(const SkPath& path, SkClipOp op, bool aa) {
         this->onClipPath(path, op, aa);
     }
+    void clipShader(sk_sp<SkShader> sh, SkClipOp op) {
+        this->onClipShader(std::move(sh), op);
+    }
     void clipRegion(const SkRegion& region, SkClipOp op) {
         this->onClipRegion(region, op);
     }
@@ -184,6 +188,7 @@ class SkBaseDevice : public SkRefCnt {
     virtual void onClipRect(const SkRect& rect, SkClipOp, bool aa) {}
     virtual void onClipRRect(const SkRRect& rrect, SkClipOp, bool aa) {}
     virtual void onClipPath(const SkPath& path, SkClipOp, bool aa) {}
+    virtual void onClipShader(sk_sp<SkShader>, SkClipOp) {}
     virtual void onClipRegion(const SkRegion& deviceRgn, SkClipOp) {}
     virtual void onSetDeviceClipRestriction(SkIRect* mutableClipRestriction) {}
     virtual bool onClipIsAA() const = 0;

src/core/SkDraw.cpp

@@ -1102,7 +1102,8 @@ void SkDraw::drawBitmap(const SkBitmap& bitmap, const SkMatrix& prematrix,
         if (clipHandlesSprite(*fRC, ix, iy, pmap)) {
             SkSTArenaAlloc<kSkBlitterContextSize> allocator;
             // blitter will be owned by the allocator.
-            SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, *paint, pmap, ix, iy, &allocator);
+            SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, *paint, pmap, ix, iy, &allocator,
+                                                         fRC->clipShader());
             if (blitter) {
                 SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()),
                                   *fRC, blitter);
@@ -1157,7 +1158,8 @@ void SkDraw::drawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint& ori
     if (nullptr == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
         // blitter will be owned by the allocator.
         SkSTArenaAlloc<kSkBlitterContextSize> allocator;
-        SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
+        SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator,
+                                                     fRC->clipShader());
         if (blitter) {
             SkScan::FillIRect(bounds, *fRC, blitter);
             return;

src/core/SkDraw_atlas.cpp

@@ -12,6 +12,7 @@
 #include "src/core/SkColorSpaceXformSteps.h"
 #include "src/core/SkCoreBlitters.h"
 #include "src/core/SkDraw.h"
+#include "src/core/SkRasterClip.h"
 #include "src/core/SkRasterPipeline.h"
 #include "src/core/SkScan.h"
 #include "src/shaders/SkShaderBase.h"
@@ -99,7 +100,8 @@ void SkDraw::drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRe
         isOpaque = false;
     }
 
-    auto blitter = SkCreateRasterPipelineBlitter(fDst, p, pipeline, isOpaque, &alloc);
+    auto blitter = SkCreateRasterPipelineBlitter(fDst, p, pipeline, isOpaque, &alloc,
+                                                 fRC->clipShader());
     SkPath scratchPath;
 
     for (int i = 0; i < count; ++i) {

src/core/SkDraw_text.cpp

@@ -37,11 +37,11 @@ void SkDraw::paintMasks(SkDrawableGlyphBuffer* drawables, const SkPaint& paint)
 
     // The size used for a typical blitter.
     SkSTArenaAlloc<3308> alloc;
-    SkBlitter* blitter = SkBlitter::Choose(fDst, *fMatrix, paint, &alloc, false);
+    SkBlitter* blitter = SkBlitter::Choose(fDst, *fMatrix, paint, &alloc, false, fRC->clipShader());
     if (fCoverage) {
         blitter = alloc.make<SkPairBlitter>(
-                blitter,
-                SkBlitter::Choose(*fCoverage, *fMatrix, SkPaint(), &alloc, true));
+            blitter,
+            SkBlitter::Choose(*fCoverage, *fMatrix, SkPaint(), &alloc, true, fRC->clipShader()));
     }
 
     SkAAClipBlitterWrapper wrapper{*fRC, blitter};