composeshader.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/private/base/SkTDArray.h"
#include "src/base/SkTLazy.h"
#include "tools/GpuToolUtils.h"
#include "tools/ToolUtils.h"
#include <utility>

Go to the source code of this file.

Classes
class	ComposeShaderGM
class	ComposeShaderAlphaGM
class	ComposeShaderBitmapGM

Functions
static sk_sp< SkShader >	make_shader (SkBlendMode mode)
static void	draw_color_bm (SkBitmap *bm, int length)
static void	draw_alpha8_bm (SkBitmap *bm, int length)
static sk_sp< SkShader >	make_linear_gradient_shader (int length)
	DEF_SIMPLE_GM (composeshader_bitmap2, canvas, 200, 200)
static sk_sp< SkShader >	make_src_shader (SkScalar size)
static sk_sp< SkShader >	make_dst_shader (SkScalar size)
static void	draw_cell (SkCanvas *canvas, sk_sp< SkShader > src, sk_sp< SkShader > dst, SkBlendMode mode, SkAlpha alpha)
static void	draw_composed (SkCanvas *canvas, sk_sp< SkShader > src, sk_sp< SkShader > dst, SkBlendMode mode, SkAlpha alpha)
static void	draw_pair (SkCanvas *canvas, sk_sp< SkShader > src, sk_sp< SkShader > dst, SkBlendMode mode)
	DEF_SIMPLE_GM (composeshader_grid, canvas, 882, 882)

Variables
const SkScalar	gCellSize = 100

Function Documentation

DEF_SIMPLE_GM() [1/2]

DEF_SIMPLE_GM	(	composeshader_bitmap2	,
		canvas	,
		200	,
		200
	)

Definition at line 253 of file composeshader.cpp.

                                                       {
    int width = 255;
    int height = 255;
    SkTDArray<uint8_t> dst8Storage;
    dst8Storage.resize(width * height);
    SkTDArray<uint32_t> dst32Storage;
    dst32Storage.resize(width * height * sizeof(int32_t));
    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            dst8Storage[y * width + x] = (y + x) / 2;
            dst32Storage[y * width + x] = SkPackARGB32(0xFF, x, y, 0);
        }
    }
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setColor(SK_ColorBLUE);
    SkRect r = {0, 0, SkIntToScalar(width), SkIntToScalar(height)};
    canvas->drawRect(r, paint);
    SkBitmap skBitmap, skMask;
    SkImageInfo imageInfo = SkImageInfo::Make(width, height,
            SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
    skBitmap.installPixels(imageInfo, dst32Storage.begin(), width * sizeof(int32_t),
                           nullptr, nullptr);
    imageInfo = SkImageInfo::Make(width, height,
            SkColorType::kAlpha_8_SkColorType, kPremul_SkAlphaType);
    skMask.installPixels(imageInfo, dst8Storage.begin(), width, nullptr, nullptr);
    sk_sp<SkImage> skSrc = skBitmap.asImage();
    sk_sp<SkImage> skMaskImage = skMask.asImage();
    paint.setShader(
        SkShaders::Blend(SkBlendMode::kSrcIn,
                         skMaskImage->makeShader(SkSamplingOptions()),
                         skSrc->makeShader(SkSamplingOptions())));
    canvas->drawRect(r, paint);
}

DEF_SIMPLE_GM() [2/2]

DEF_SIMPLE_GM	(	composeshader_grid	,
		canvas	,
		882	,
		882
	)

Definition at line 355 of file composeshader.cpp.

                                                    {
    auto src = make_src_shader(gCellSize);
    auto dst = make_dst_shader(gCellSize);
 
    const SkScalar margin = 15;
    const SkScalar dx = 2*gCellSize + margin;
    const SkScalar dy = 2*gCellSize + margin;
 
    canvas->translate(margin, margin);
    canvas->save();
    for (int m = 0; m < 16; ++m) {
        SkBlendMode mode = static_cast<SkBlendMode>(m);
        draw_pair(canvas, src, dst, mode);
        if ((m % 4) == 3) {
            canvas->restore();
            canvas->translate(0, dy);
            canvas->save();
        } else {
            canvas->translate(dx, 0);
        }
    }
    canvas->restore();
}

draw_alpha8_bm()

static void draw_alpha8_bm ( SkBitmap *  bm, int  length  )

static

Definition at line 137 of file composeshader.cpp.

                                                     {
    SkPaint circlePaint;
    circlePaint.setColor(SK_ColorBLACK);
 
    bm->allocPixels(SkImageInfo::MakeA8(length, length));
    bm->eraseColor(SK_ColorTRANSPARENT);
 
    SkCanvas canvas(*bm);
    canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/4),
                      circlePaint);
}

draw_cell()

static void draw_cell ( SkCanvas *  canvas, sk_sp< SkShader >  src, sk_sp< SkShader >  dst, SkBlendMode  mode, SkAlpha  alpha  )

static

Definition at line 304 of file composeshader.cpp.

                                                       {
    const SkRect r = SkRect::MakeWH(gCellSize, gCellSize);
    SkPaint p;
    p.setAlpha(alpha);
 
    SkAutoCanvasRestore acr(canvas, false);
    canvas->saveLayer(&r, &p);
    p.setAlpha(0xFF);
 
    p.setShader(dst);
    p.setBlendMode(SkBlendMode::kSrc);
    canvas->drawRect(r, p);
 
    p.setShader(src);
    p.setBlendMode(mode);
    canvas->drawRect(r, p);
}

draw_color_bm()

static void draw_color_bm ( SkBitmap *  bm, int  length  )

static

Definition at line 124 of file composeshader.cpp.

                                                    {
    SkPaint paint;
    paint.setColor(SK_ColorGREEN);
 
    bm->allocN32Pixels(length, length);
    bm->eraseColor(SK_ColorRED);
 
    SkCanvas canvas(*bm);
    canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/2),
                      paint);
}

draw_composed()

static void draw_composed ( SkCanvas *  canvas, sk_sp< SkShader >  src, sk_sp< SkShader >  dst, SkBlendMode  mode, SkAlpha  alpha  )

static

Definition at line 323 of file composeshader.cpp.

                                                           {
    SkPaint p;
    p.setAlpha(alpha);
    p.setShader(SkShaders::Blend(mode, dst, src));
    canvas->drawRect(SkRect::MakeWH(gCellSize, gCellSize), p);
}

draw_pair()

static void draw_pair ( SkCanvas *  canvas, sk_sp< SkShader >  src, sk_sp< SkShader >  dst, SkBlendMode  mode  )

static

Definition at line 331 of file composeshader.cpp.

                                        {
    SkAutoCanvasRestore acr(canvas, true);
 
    const SkScalar gap = 4;
    SkRect r = SkRect::MakeWH(2 * gCellSize + gap, 2 * gCellSize + gap);
    r.outset(gap + 1.5f, gap + 1.5f);
    SkPaint p;
    p.setStyle(SkPaint::kStroke_Style);
    canvas->drawRect(r, p); // border
 
    SkAlpha alpha = 0xFF;
    for (int y = 0; y < 2; ++y) {
        draw_cell(canvas, src, dst, mode, alpha);
        canvas->save();
        canvas->translate(gCellSize + gap, 0);
        draw_composed(canvas, src, dst, mode, alpha);
        canvas->restore();
 
        canvas->translate(0, gCellSize + gap);
        alpha = 0x80;
    }
}

make_dst_shader()

static sk_sp< SkShader > make_dst_shader ( SkScalar  size )

static

Definition at line 296 of file composeshader.cpp.

                                                      {
    const SkPoint pts[] = { { 0, 0 }, { size, 0 } };
    const SkColor colors[] = { SK_ColorRED, 0x00FF0000 };
    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
}

make_linear_gradient_shader()

static sk_sp< SkShader > make_linear_gradient_shader ( int  length )

static

Definition at line 150 of file composeshader.cpp.

                                                               {
    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::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
}

make_shader()

static sk_sp< SkShader > make_shader ( SkBlendMode  mode )

static

Definition at line 35 of file composeshader.cpp.

                                                     {
    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;
    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
    pts[0].set(0, 0);
    pts[1].set(0, SkIntToScalar(100));
    colors[0] = SK_ColorBLACK;
    colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
    auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
 
    return SkShaders::Blend(mode, std::move(shaderA), std::move(shaderB));
}

make_src_shader()

static sk_sp< SkShader > make_src_shader ( SkScalar  size )

static

Definition at line 290 of file composeshader.cpp.

                                                      {
    const SkPoint pts[] = { { 0, 0 }, { 0, size } };
    const SkColor colors[] = { 0xFF0000FF, 0x000000FF };
    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
}

Variable Documentation

gCellSize

const SkScalar gCellSize = 100

Definition at line 302 of file composeshader.cpp.