blurrect.cpp File Reference

#include <cmath>
#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkImage.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathBuilder.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/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkBlurMask.h"
#include "src/core/SkMask.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "tools/timer/TimeUtils.h"
#include <vector>

Go to the source code of this file.

Classes
class	BlurRectGM

Namespaces
namespace	skiagm

Macros
#define	STROKE_WIDTH   SkIntToScalar(10)

Typedefs
typedef void(*	Proc) (SkCanvas *, const SkRect &, const SkPaint &)
typedef void(*	PaintProc) (SkPaint *, SkScalar width)

Functions
static void	fill_rect (SkCanvas *canvas, const SkRect &r, const SkPaint &p)
static void	draw_donut (SkCanvas *canvas, const SkRect &r, const SkPaint &p)
static void	draw_donut_skewed (SkCanvas *canvas, const SkRect &r, const SkPaint &p)
static sk_sp< SkShader >	make_radial ()
	DEF_SIMPLE_GM (blurrect_gallery, canvas, 1200, 1024)
	DEF_SIMPLE_GM (blur_matrix_rect, canvas, 650, 685)

Macro Definition Documentation

STROKE_WIDTH

#define STROKE_WIDTH   SkIntToScalar(10)

Definition at line 40 of file blurrect.cpp.

Typedef Documentation

PaintProc

typedef void(* PaintProc) (SkPaint *, SkScalar width)

Definition at line 107 of file blurrect.cpp.

Proc

typedef void(* Proc) (SkCanvas *, const SkRect &, const SkPaint &)

Definition at line 42 of file blurrect.cpp.

Function Documentation

DEF_SIMPLE_GM() [1/2]

DEF_SIMPLE_GM	(	blur_matrix_rect	,
		canvas	,
		650	,
		685
	)

Definition at line 509 of file blurrect.cpp.

                                                  {
    static constexpr auto kRect = SkRect::MakeWH(14, 60);
    static constexpr float kSigmas[] = {0.5f, 1.2f, 2.3f, 3.9f, 7.4f};
    static constexpr size_t kNumSigmas = std::size(kSigmas);
 
    const SkPoint c = {kRect.centerX(), kRect.centerY()};
 
    std::vector<SkMatrix> matrices;
 
    matrices.push_back(SkMatrix::RotateDeg(4.f, c));
 
    matrices.push_back(SkMatrix::RotateDeg(63.f, c));
 
    matrices.push_back(SkMatrix::RotateDeg(30.f, c));
    matrices.back().preScale(1.1f, .5f);
 
    matrices.push_back(SkMatrix::RotateDeg(147.f, c));
    matrices.back().preScale(3.f, .1f);
 
    SkMatrix mirror;
    mirror.setAll(0, 1, 0,
                  1, 0, 0,
                  0, 0, 1);
    matrices.push_back(SkMatrix::Concat(mirror, matrices.back()));
 
    matrices.push_back(SkMatrix::RotateDeg(197.f, c));
    matrices.back().preSkew(.3f, -.5f);
 
    auto bounds = SkRect::MakeEmpty();
    for (const auto& m : matrices) {
        SkRect mapped;
        m.mapRect(&mapped, kRect);
        bounds.joinNonEmptyArg(mapped.makeSorted());
    }
    float blurPad = 2.f*kSigmas[kNumSigmas - 1];
    bounds.outset(blurPad, blurPad);
    canvas->translate(-bounds.left(), -bounds.top());
    for (auto sigma : kSigmas) {
        SkPaint paint;
        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
        canvas->save();
        for (const auto& m : matrices) {
            canvas->save();
            canvas->concat(m);
            canvas->drawRect(kRect, paint);
            canvas->restore();
            canvas->translate(0, bounds.height());
        }
        canvas->restore();
        canvas->translate(bounds.width(), 0);
    }
}

DEF_SIMPLE_GM() [2/2]

DEF_SIMPLE_GM	(	blurrect_gallery	,
		canvas	,
		1200	,
		1024
	)

Definition at line 186 of file blurrect.cpp.

                                                    {
        const int fGMWidth = 1200;
        const int fPadding = 10;
        const int fMargin = 100;
 
        const int widths[] = {25, 5, 5, 100, 150, 25};
        const int heights[] = {100, 100, 5, 25, 150, 25};
        const SkBlurStyle styles[] = {kNormal_SkBlurStyle, kInner_SkBlurStyle, kOuter_SkBlurStyle};
        const float radii[] = {20, 5, 10};
 
        canvas->translate(50,20);
 
        int cur_x = 0;
        int cur_y = 0;
 
        int max_height = 0;
 
        for (size_t i = 0 ; i < std::size(widths) ; i++) {
            int width = widths[i];
            int height = heights[i];
            SkRect r;
            r.setWH(SkIntToScalar(width), SkIntToScalar(height));
            SkAutoCanvasRestore autoRestore(canvas, true);
 
            for (size_t j = 0 ; j < std::size(radii) ; j++) {
                float radius = radii[j];
                for (size_t k = 0 ; k < std::size(styles) ; k++) {
                    SkBlurStyle style = styles[k];
 
                    SkMaskBuilder mask;
                    if (!SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(radius),
                                              &mask, r, style)) {
                        continue;
                    }
 
                    SkAutoMaskFreeImage amfi(mask.image());
 
                    SkBitmap bm;
                    bm.installMaskPixels(mask);
 
                    if (cur_x + bm.width() >= fGMWidth - fMargin) {
                        cur_x = 0;
                        cur_y += max_height + fPadding;
                        max_height = 0;
                    }
 
                    canvas->save();
                    canvas->translate((SkScalar)cur_x, (SkScalar)cur_y);
                    canvas->translate(-(bm.width() - r.width())/2, -(bm.height()-r.height())/2);
                    canvas->drawImage(bm.asImage(), 0.f, 0.f);
                    canvas->restore();
 
                    cur_x += bm.width() + fPadding;
                    if (bm.height() > max_height)
                        max_height = bm.height();
                }
            }
        }
}

draw_donut()

static void draw_donut ( SkCanvas *  canvas, const SkRect &  r, const SkPaint &  p  )

static

Definition at line 48 of file blurrect.cpp.

                                                                            {
    SkRect        rect;
    SkPathBuilder path;
 
    rect = r;
    rect.outset(STROKE_WIDTH/2, STROKE_WIDTH/2);
    path.addRect(rect);
    rect = r;
    rect.inset(STROKE_WIDTH/2, STROKE_WIDTH/2);
 
    path.addRect(rect);
    path.setFillType(SkPathFillType::kEvenOdd);
 
    canvas->drawPath(path.detach(), p);
}

draw_donut_skewed()

static void draw_donut_skewed ( SkCanvas *  canvas, const SkRect &  r, const SkPaint &  p  )

static

Definition at line 64 of file blurrect.cpp.

                                                                                   {
    SkRect        rect;
    SkPathBuilder path;
 
    rect = r;
    rect.outset(STROKE_WIDTH/2, STROKE_WIDTH/2);
    path.addRect(rect);
    rect = r;
    rect.inset(STROKE_WIDTH/2, STROKE_WIDTH/2);
 
    rect.offset(7, -7);
 
    path.addRect(rect);
    path.setFillType(SkPathFillType::kEvenOdd);
 
    canvas->drawPath(path.detach(), p);
}

fill_rect()

static void fill_rect ( SkCanvas *  canvas, const SkRect &  r, const SkPaint &  p  )

static

Definition at line 44 of file blurrect.cpp.

                                                                           {
    canvas->drawRect(r, p);
}

make_radial()

static sk_sp< SkShader > make_radial ( )

static

Definition at line 85 of file blurrect.cpp.

                                     {
    SkPoint pts[2] = {
        { 0, 0 },
        { SkIntToScalar(100), SkIntToScalar(100) }
    };
    SkTileMode tm = SkTileMode::kClamp;
    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, };
    const SkScalar pos[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
    SkMatrix scale;
    scale.setScale(0.5f, 0.5f);
    scale.postTranslate(25.f, 25.f);
    SkPoint center0, center1;
    center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
    center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
    return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                 center0, (pts[1].fX - pts[0].fX) / 2,
                                                 colors, pos, std::size(colors), tm,
                                                 0, &scale);
}