KawaseBlurFilter Class Reference

Public Member Functions
	KawaseBlurFilter ()
void	draw (SkCanvas *canvas, sk_sp< SkImage > input, int blurRadius)

Static Public Member Functions
static sk_sp< SkSurface >	MakeSurface (SkCanvas *canvas, const SkImageInfo &info)

Static Public Attributes
static constexpr float	kInputScale = 0.25f
static constexpr float	kInverseInputScale = 1.0f / kInputScale
static constexpr uint32_t	kMaxPasses = 4
static constexpr float	kMaxCrossFadeRadius = 30.0f

Detailed Description

Definition at line 19 of file kawase_blur_rt.cpp.

Constructor & Destructor Documentation

KawaseBlurFilter()

KawaseBlurFilter::KawaseBlurFilter ( )

inline

Definition at line 31 of file kawase_blur_rt.cpp.

                       {
        SkString blurString(R"(
            uniform shader src;
            uniform float in_inverseScale;
            uniform float2 in_blurOffset;
 
            half4 main(float2 xy) {
                float2 scaled_xy = float2(xy.x * in_inverseScale, xy.y * in_inverseScale);
 
                half4 c = src.eval(scaled_xy);
                c += src.eval(scaled_xy + float2( in_blurOffset.x,  in_blurOffset.y));
                c += src.eval(scaled_xy + float2( in_blurOffset.x, -in_blurOffset.y));
                c += src.eval(scaled_xy + float2(-in_blurOffset.x,  in_blurOffset.y));
                c += src.eval(scaled_xy + float2(-in_blurOffset.x, -in_blurOffset.y));
 
                return half4(c.rgb * 0.2, 1.0);
            }
        )");
 
        SkString mixString(R"(
            uniform shader in_blur;
            uniform shader in_original;
            uniform float in_inverseScale;
            uniform float in_mix;
 
            half4 main(float2 xy) {
                float2 scaled_xy = float2(xy.x * in_inverseScale, xy.y * in_inverseScale);
 
                half4 blurred = in_blur.eval(scaled_xy);
                half4 composition = in_original.eval(xy);
                return mix(composition, blurred, in_mix);
            }
        )");
 
        auto [blurEffect, error] = SkRuntimeEffect::MakeForShader(blurString);
        if (!blurEffect) {
            SkDEBUGFAILF("RuntimeShader error: %s\n", error.c_str());
        }
        fBlurEffect = std::move(blurEffect);
 
        auto [mixEffect, error2] = SkRuntimeEffect::MakeForShader(mixString);
        if (!mixEffect) {
            SkDEBUGFAILF("RuntimeShader error: %s\n", error2.c_str());
        }
        fMixEffect = std::move(mixEffect);
    }

Member Function Documentation

draw()

void KawaseBlurFilter::draw ( SkCanvas *  canvas, sk_sp< SkImage >  input, int  blurRadius  )

inline

Definition at line 86 of file kawase_blur_rt.cpp.

                                                                      {
        // NOTE: this is only experimental and the current blur params cause points to be sampled
        // beyond the input blur radius.
 
        // Kawase is an approximation of Gaussian, but it behaves differently from it.
        // A radius transformation is required for approximating them, and also to introduce
        // non-integer steps, necessary to smoothly interpolate large radii.
        float tmpRadius = (float)blurRadius / 6.0f;
        float numberOfPasses = std::min(kMaxPasses, (uint32_t)ceil(tmpRadius));
        float radiusByPasses = tmpRadius / (float)numberOfPasses;
 
        SkImageInfo scaledInfo = SkImageInfo::MakeN32Premul((float)input->width() * kInputScale,
                                                            (float)input->height() * kInputScale);
        auto drawSurface = MakeSurface(canvas, scaledInfo);
 
        const float stepX = radiusByPasses;
        const float stepY = radiusByPasses;
 
        // start by drawing and downscaling and doing the first blur pass
        SkRuntimeShaderBuilder blurBuilder(fBlurEffect);
        blurBuilder.child("src") = input->makeShader(SkSamplingOptions(SkFilterMode::kLinear));
        blurBuilder.uniform("in_inverseScale") = kInverseInputScale;
        blurBuilder.uniform("in_blurOffset") = SkV2{stepX * kInverseInputScale,
                                                    stepY * kInverseInputScale};
        SkPaint paint;
        paint.setShader(blurBuilder.makeShader());
        drawSurface->getCanvas()->drawIRect(scaledInfo.bounds(), paint);
 
        // DEBUG draw each of the stages
        canvas->save();
        canvas->drawImage(drawSurface->makeImageSnapshot(), input->width() / 4, 0,
                          SkSamplingOptions());
        canvas->translate(input->width() / 4, input->height() * 0.75);
 
        // And now we'll ping pong between our surfaces, to accumulate the result of various
        // offsets.
        auto lastDrawTarget = drawSurface;
        if (numberOfPasses > 1) {
            auto readSurface = drawSurface;
            drawSurface = MakeSurface(canvas, scaledInfo);
 
            for (auto i = 1; i < numberOfPasses; i++) {
                const float stepScale = (float)i * kInputScale;
 
                blurBuilder.child("src") = readSurface->makeImageSnapshot()->makeShader(
                        SkSamplingOptions(SkFilterMode::kLinear));
                blurBuilder.uniform("in_inverseScale") = 1.0f;
                blurBuilder.uniform("in_blurOffset") = SkV2{stepX * stepScale , stepY * stepScale};
 
                paint.setShader(blurBuilder.makeShader());
                drawSurface->getCanvas()->drawIRect(scaledInfo.bounds(), paint);
 
                // DEBUG draw each of the stages
                canvas->drawImage(drawSurface->makeImageSnapshot(), 0, 0, SkSamplingOptions());
                canvas->translate(0, input->height() * 0.75);
 
                // Swap buffers for next iteration
                auto tmp = drawSurface;
                drawSurface = readSurface;
                readSurface = tmp;
            }
            lastDrawTarget = readSurface;
        }
 
        // restore translations done for debug and offset
        canvas->restore();
        SkAutoCanvasRestore acr(canvas, true);
        canvas->translate(input->width(), 0);
 
        // do the final composition and when we scale our blur up. It will be interpolated
        // with the larger composited texture to hide downscaling artifacts.
        SkRuntimeShaderBuilder mixBuilder(fMixEffect);
        mixBuilder.child("in_blur") = lastDrawTarget->makeImageSnapshot()->makeShader(
                SkSamplingOptions(SkFilterMode::kLinear));
        mixBuilder.child("in_original") =
                input->makeShader(SkSamplingOptions(SkFilterMode::kLinear));
        mixBuilder.uniform("in_inverseScale") = kInputScale;
        mixBuilder.uniform("in_mix") = std::min(1.0f, (float)blurRadius / kMaxCrossFadeRadius);
 
        paint.setShader(mixBuilder.makeShader());
        canvas->drawIRect(input->bounds(), paint);
    }

MakeSurface()

static sk_sp< SkSurface > KawaseBlurFilter::MakeSurface ( SkCanvas *  canvas, const SkImageInfo &  info  )

inlinestatic

Definition at line 78 of file kawase_blur_rt.cpp.

                                                                                   {
        if (sk_sp<SkSurface> surface = canvas->makeSurface(info)) {
            return surface;
        }
        // serialize-8888 returns null from makeSurface; fallback to a raster surface.
        return SkSurfaces::Raster(info);
    }

Member Data Documentation

kInputScale

constexpr float KawaseBlurFilter::kInputScale = 0.25f

staticconstexpr

Definition at line 22 of file kawase_blur_rt.cpp.

kInverseInputScale

constexpr float KawaseBlurFilter::kInverseInputScale = 1.0f / kInputScale

staticconstexpr

Definition at line 24 of file kawase_blur_rt.cpp.

kMaxCrossFadeRadius

constexpr float KawaseBlurFilter::kMaxCrossFadeRadius = 30.0f

staticconstexpr

Definition at line 29 of file kawase_blur_rt.cpp.

kMaxPasses

constexpr uint32_t KawaseBlurFilter::kMaxPasses = 4

staticconstexpr

Definition at line 26 of file kawase_blur_rt.cpp.

---

The documentation for this class was generated from the following file:

• third_party/skia/gm/kawase_blur_rt.cpp