Added ComposeShaderBitmapGM that tests composing bitmaps with gradients

gm/composeshader.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 
 #include "SkCanvas.h"
 #include "SkComposeShader.h"
 #include "SkGradientShader.h"
 #include "SkGraphics.h"
 #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];
     SkColor colors[2];
 
     pts[0].set(0, 0);
     pts[1].set(SkIntToScalar(100), 0);
     colors[0] = SK_ColorRED;
     colors[1] = SK_ColorBLUE;
     SkAutoTUnref<SkShader> shaderA(SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
@@ skipping 50 matching lines @@
 class ComposeShaderAlphaGM : public skiagm::GM {
 public:
     ComposeShaderAlphaGM() {}
 
 protected:
     SkString onShortName() override {
         return SkString("composeshader_alpha");
     }
 
     SkISize onISize() override {
-        return SkISize::Make(220, 750);
+        return SkISize::Make(750, 220);
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkAutoTUnref<SkShader> shader0(make_shader(SkXfermode::kDstIn_Mode));
         SkAutoTUnref<SkShader> shader1(make_shader(SkXfermode::kSrcOver_Mode));
         SkShader* shaders[] = { shader0.get(), shader1.get() };
 
         SkPaint paint;
         paint.setColor(SK_ColorGREEN);
 
@@ skipping 10 matching lines @@
                 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:
+    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.