Added ComposeShaderBitmapGM that tests composing bitmaps with gradients

gm/composeshader.cpp

Index: gm/composeshader.cpp
diff --git a/gm/composeshader.cpp b/gm/composeshader.cpp
index f5ab996f37e33d332e50e37ef0e6ead58660aeaa..2bcbbd327fbecf6e3dae37ebed2e58c490c6c691 100644
--- a/gm/composeshader.cpp
+++ b/gm/composeshader.cpp
@@ -14,6 +14,7 @@
 #include "SkShader.h"
 #include "SkString.h"
 #include "SkXfermode.h"
+#include "SkBitmapProcShader.h"

[egdaniel, 2015/09/02 20:15:36]

Alphabetize this include

[wangyix, 2015/09/02 20:49:35]

Done.

 
 static SkShader* make_shader(SkXfermode::Mode mode) {
     SkPoint pts[2];
@@ -84,7 +85,7 @@ protected:
     }
 
     SkISize onISize() override {
-        return SkISize::Make(220, 750);
+        return SkISize::Make(750, 220);
     }
 
     void onDraw(SkCanvas* canvas) override {
@@ -115,9 +116,127 @@ protected:
             canvas->translate(0, r.height() + 5);
         }
     }
+
+private:
+    typedef GM INHERITED ;
+};
+
+
+// creates a square bitmap with red background and a green circle in the center
+static void draw_color_bm(SkBitmap* bm, int length) {
+    SkPaint paint;
+    paint.setColor(SK_ColorGREEN);
+
+    bm->allocN32Pixels(length, length);
+    bm->eraseColor(SK_ColorRED);
+
+    SkCanvas canvas(*bm);
+    canvas.drawCircle(length/2, length/2, length/2, paint);
+}
+
+// creates a square alpha8 bitmap with transparent background and an opaque circle in the center
+static void draw_alpha8_bm(SkBitmap* bm, int length) {
+    SkPaint circlePaint;
+    circlePaint.setColor(SK_ColorBLACK);
+
+    bm->allocPixels(SkImageInfo::MakeA8(length, length));
+    bm->eraseColor(SK_ColorTRANSPARENT);
+
+    SkCanvas canvas(*bm);
+    canvas.drawCircle(length/2, length/2, length/4, circlePaint);
+}
+
+// creates a linear gradient shader
+static SkShader* make_linear_gradient_shader(int length) {
+    SkPoint pts[2];
+    SkColor colors[2];
+    pts[0].set(0, 0);
+    pts[1].set(SkIntToScalar(length), 0);
+    colors[0] = SK_ColorBLUE;
+    colors[1] = SkColorSetARGB(0, 0, 0, 0xFF);
+    return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+}
+
+
+class ComposeShaderBitmapGM : public skiagm::GM {
+public:
+    /** Can set the dimension of the bitmap that will be used.  This way, larger numbers can be

[egdaniel, 2015/09/02 20:15:36]

Are you saying this will draw differently in release and debug? We want to make
sure that those are identical

[wangyix, 2015/09/02 20:27:43]

No, I was trying to say you can easily change this number to a larger number in
the code, then compile a release build so the images show up larger and is
easier to inspect.  Maybe all this isn't necessary and the parameter should just
be removed?  

+     * used for release mode since debug mode will fail an assertion in SkSmallAllocator unless the

[egdaniel, 2015/09/02 20:15:36]

align comment

+     * size of the bitmap is sufficiently small, making the result hard to see.
+     */
+    ComposeShaderBitmapGM(int squareSize)
+        : squareLength(squareSize) {
+        draw_color_bm(&fColorBitmap, squareLength);
+        draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
+        SkMatrix s;
+        s.reset();
+        fColorBitmapShader = new SkBitmapProcShader(fColorBitmap, SkShader::kRepeat_TileMode,
+                                                    SkShader::kRepeat_TileMode, &s);
+        fAlpha8BitmapShader = new SkBitmapProcShader(fAlpha8Bitmap, SkShader::kRepeat_TileMode,
+                                                     SkShader::kRepeat_TileMode, &s);
+        fLinearGradientShader = make_linear_gradient_shader(squareLength);
+    }
+    ~ComposeShaderBitmapGM() {
+        SkSafeUnref(fColorBitmapShader);
+        SkSafeUnref(fAlpha8BitmapShader);
+        SkSafeUnref(fLinearGradientShader);
+    }
+
+protected:
+    SkString onShortName() override {
+        return SkString("composeshader_bitmap");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5));
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mode));

[egdaniel, 2015/09/02 20:15:36]

I wonder if it would be interesting to loop over xfermodes here

+
+        // gradient should appear over color bitmap
+        SkAutoTUnref<SkShader> shader0(new SkComposeShader(fLinearGradientShader,
+                                                           fColorBitmapShader,
+                                                           xfer));
+        // gradient should appear over alpha8 bitmap colorized by the paint color
+        SkAutoTUnref<SkShader> shader1(new SkComposeShader(fLinearGradientShader,
+                                                           fAlpha8BitmapShader,
+                                                           xfer));
+
+        SkShader* shaders[] = { shader0.get(), shader1.get() };
+
+        SkPaint paint;
+        paint.setColor(SK_ColorYELLOW);
+
+        const SkRect r = SkRect::MakeXYWH(0, 0, squareLength, squareLength);
+
+        for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
+            SkShader* shader = shaders[y];
+            canvas->save();
+            for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
+                paint.setAlpha(alpha);
+                paint.setShader(shader);
+                canvas->drawRect(r, paint);
+
+                canvas->translate(r.width() + 5, 0);
+            }
+            canvas->restore();
+            canvas->translate(0, r.height() + 5);
+        }
+    }
+private:
+    const int squareLength;
+    SkBitmap fColorBitmap;
+    SkBitmap fAlpha8Bitmap;
+    SkShader* fColorBitmapShader;
+    SkShader* fAlpha8BitmapShader;
+    SkShader* fLinearGradientShader;
+
+    typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return new ComposeShaderGM; )
 DEF_GM( return new ComposeShaderAlphaGM; )
+DEF_GM( return new ComposeShaderBitmapGM(20); )

[egdaniel, 2015/09/02 20:15:36]

This is a general question to anyone, but do we have any other gm's that take in
a param like this? Would it make more sense to declare some const value within
the code itself and if someone wanted to make it larger they could come in and
update that const. I at least feel that is more uniform with other gms but I may
be wrong.