tilemodes.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.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/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/utils/SkTextUtils.h"
#include "tools/DecodeUtils.h"
#include "tools/GpuToolUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include <functional>

Go to the source code of this file.

Classes
class	TilingGM
class	Tiling2GM

Typedefs
typedef sk_sp< SkShader >(*	ShaderProc) (SkTileMode, SkTileMode)

Functions
static void	makebm (SkBitmap *bm, SkColorType ct, int w, int h)
static void	setup (SkCanvas *canvas, SkPaint *paint, const SkBitmap &bm, SkFilterMode fm, SkTileMode tmx, SkTileMode tmy)
static sk_sp< SkShader >	make_bm (SkTileMode tx, SkTileMode ty)
static sk_sp< SkShader >	make_grad (SkTileMode tx, SkTileMode ty)
	DEF_SIMPLE_GM (tilemode_decal, canvas, 720, 1100)

Variables
constexpr SkColorType	gColorTypes []
constexpr int	gWidth = 32
constexpr int	gHeight = 32

Typedef Documentation

ShaderProc

typedef sk_sp< SkShader >(* ShaderProc) (SkTileMode, SkTileMode)

Definition at line 201 of file tilemodes.cpp.

Function Documentation

DEF_SIMPLE_GM()

DEF_SIMPLE_GM	(	tilemode_decal	,
		canvas	,
		720	,
		1100
	)

Definition at line 272 of file tilemodes.cpp.

                                                 {
    auto img = ToolUtils::GetResourceAsImage("images/mandrill_128.png");
    SkPaint bgpaint;
    bgpaint.setColor(SK_ColorYELLOW);
 
    SkRect r = { -20, -20, img->width() + 20.0f, img->height() + 20.0f };
    canvas->translate(45, 45);
 
    std::function<void(SkPaint*, SkTileMode, SkTileMode)> shader_procs[] = {
        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
            // Test no filtering with decal mode
            paint->setShader(img->makeShader(tx, ty, SkSamplingOptions(SkFilterMode::kNearest)));
        },
        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
            // Test bilerp approximation for decal mode (or clamp to border HW)
            paint->setShader(img->makeShader(tx, ty, SkSamplingOptions(SkFilterMode::kLinear)));
        },
        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
            // Test bicubic filter with decal mode
            paint->setShader(img->makeShader(tx, ty, SkSamplingOptions(SkCubicResampler::Mitchell())));
        },
        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
            SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
            const SkPoint pts[] = {{ 0, 0 }, {img->width()*1.0f, img->height()*1.0f }};
            const SkScalar* pos = nullptr;
            const int count = std::size(colors);
            paint->setShader(SkGradientShader::MakeLinear(pts, colors, pos, count, tx));
        },
        [img](SkPaint* paint, SkTileMode tx, SkTileMode ty) {
            SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
            const SkScalar* pos = nullptr;
            const int count = std::size(colors);
            paint->setShader(SkGradientShader::MakeRadial({ img->width()*0.5f, img->width()*0.5f },
                                                      img->width()*0.5f, colors, pos, count, tx));
        },
    };
 
    const struct XY {
        SkTileMode  fX;
        SkTileMode  fY;
    } pairs[] = {
        { SkTileMode::kClamp,    SkTileMode::kClamp },
        { SkTileMode::kClamp,    SkTileMode::kDecal },
        { SkTileMode::kDecal,    SkTileMode::kClamp },
        { SkTileMode::kDecal,    SkTileMode::kDecal },
    };
    for (const auto& p : pairs) {
        SkPaint paint;
        canvas->save();
        for (const auto& proc : shader_procs) {
            canvas->save();
            // Apply a slight rotation to highlight the differences between filtered and unfiltered
            // decal edges
            canvas->rotate(4);
            canvas->drawRect(r, bgpaint);
            proc(&paint, p.fX, p.fY);
            canvas->drawRect(r, paint);
            canvas->restore();
            canvas->translate(0, r.height() + 20);
        }
        canvas->restore();
        canvas->translate(r.width() + 10, 0);
    }
}

make_bm()

static sk_sp< SkShader > make_bm ( SkTileMode  tx, SkTileMode  ty  )

static

Definition at line 176 of file tilemodes.cpp.

                                                             {
    SkBitmap bm;
    makebm(&bm, kN32_SkColorType, gWidth, gHeight);
    return bm.makeShader(tx, ty, SkSamplingOptions());
}

make_grad()

static sk_sp< SkShader > make_grad ( SkTileMode  tx, SkTileMode  ty  )

static

Definition at line 182 of file tilemodes.cpp.

                                                               {
    SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(gWidth), SkIntToScalar(gHeight)} };
    SkPoint center = { SkIntToScalar(gWidth)/2, SkIntToScalar(gHeight)/2 };
    SkScalar rad = SkIntToScalar(gWidth)/2;
    SkColor  colors[] = {0xFFFF0000, ToolUtils::color_to_565(0xFF0044FF)};
 
    int index = (int)ty;
    switch (index % 3) {
        case 0:
            return SkGradientShader::MakeLinear(pts, colors, nullptr, std::size(colors), tx);
        case 1:
            return SkGradientShader::MakeRadial(center, rad, colors, nullptr, std::size(colors), tx);
        case 2:
            return SkGradientShader::MakeSweep(center.fX, center.fY, colors, nullptr,
                                               std::size(colors), tx, 135, 225, 0, nullptr);
    }
    return nullptr;
}

makebm()

static void makebm ( SkBitmap *  bm, SkColorType  ct, int  w, int  h  )

static

Definition at line 36 of file tilemodes.cpp.

                                                               {
    bm->allocPixels(SkImageInfo::Make(w, h, ct, kPremul_SkAlphaType));
    bm->eraseColor(SK_ColorTRANSPARENT);
 
    SkCanvas    canvas(*bm);
    SkPoint     pts[] = { { 0, 0 }, { SkIntToScalar(w), SkIntToScalar(h)} };
    SkColor     colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
    SkScalar    pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
    SkPaint     paint;
 
    paint.setDither(true);
    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, std::size(colors),
                                                 SkTileMode::kClamp));
    canvas.drawPaint(paint);
}

setup()

static void setup ( SkCanvas *  canvas, SkPaint *  paint, const SkBitmap &  bm, SkFilterMode  fm, SkTileMode  tmx, SkTileMode  tmy  )

static

Definition at line 52 of file tilemodes.cpp.

                                                  {
    sk_sp<SkImage> img = SkImages::RasterFromBitmap(bm);
    img = ToolUtils::MakeTextureImage(canvas, std::move(img));
    if (img) {
        // img can be null if the GPU context has been abandoned.
        paint->setShader(img->makeShader(tmx, tmy, SkSamplingOptions(fm)));
    }
}

Variable Documentation

gColorTypes

constexpr SkColorType gColorTypes[]

constexpr

Initial value:

= {
    kN32_SkColorType,
    kRGB_565_SkColorType,
}

Definition at line 62 of file tilemodes.cpp.

                                      {
    kN32_SkColorType,
    kRGB_565_SkColorType,
};

gHeight

constexpr int gHeight = 32

constexpr

Definition at line 174 of file tilemodes.cpp.

gWidth

constexpr int gWidth = 32

constexpr

Definition at line 173 of file tilemodes.cpp.