runtimeshader.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkPaint.h"
#include "include/core/SkRRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/gpu/GrRecordingContext.h"
#include "src/base/SkRandom.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"

Go to the source code of this file.

Classes
class	RuntimeShaderGM
class	SimpleRT
class	ThresholdRT
class	SpiralRT
class	UnsharpRT
class	ColorCubeRT
class	ColorCubeColorFilterRT
class	ClipSuperRRect
class	LinearGradientRT

Enumerations
enum	RT_Flags { kAnimate_RTFlag = 0x1 , kBench_RTFlag = 0x2 , kColorFilter_RTFlag = 0x4 }

Functions
static sk_sp< SkShader >	make_shader (sk_sp< SkImage > img, SkISize size)
static sk_sp< SkShader >	make_threshold (SkISize size)
	DEF_SIMPLE_GM (child_sampling_rt, canvas, 256, 256)
static sk_sp< SkShader >	normal_map_shader ()
static sk_sp< SkImage >	normal_map_image ()
static sk_sp< SkShader >	normal_map_image_shader ()
static sk_sp< SkShader >	normal_map_raw_image_shader ()
static sk_sp< SkImage >	normal_map_unpremul_image ()
static sk_sp< SkShader >	normal_map_unpremul_image_shader ()
static sk_sp< SkShader >	normal_map_raw_unpremul_image_shader ()
static sk_sp< SkShader >	lit_shader (sk_sp< SkShader > normals)
static sk_sp< SkShader >	lit_shader_linear (sk_sp< SkShader > normals)
	DEF_SIMPLE_GM (paint_alpha_normals_rt, canvas, 512, 512)
	DEF_SIMPLE_GM (raw_image_shader_normals_rt, canvas, 768, 512)
	DEF_SIMPLE_GM (lit_shader_linear_rt, canvas, 512, 256)
	DEF_SIMPLE_GM (local_matrix_shader_rt, canvas, 256, 256)
	DEF_SIMPLE_GM (null_child_rt, canvas, 150, 100)
	DEF_SIMPLE_GM_CAN_FAIL (deferred_shader_rt, canvas, errorMsg, 150, 50)
sk_sp< SkShader >	paint_color_shader ()
	DEF_SIMPLE_GM_CAN_FAIL (alpha_image_shader_rt, canvas, errorMsg, 350, 50)

Enumeration Type Documentation

RT_Flags

enum RT_Flags

Enumerator
kAnimate_RTFlag
kBench_RTFlag
kColorFilter_RTFlag

Definition at line 28 of file runtimeshader.cpp.

              {
    kAnimate_RTFlag     = 0x1,
    kBench_RTFlag       = 0x2,
    kColorFilter_RTFlag = 0x4,
};

Function Documentation

DEF_SIMPLE_GM() [1/6]

DEF_SIMPLE_GM	(	child_sampling_rt	,
		canvas	,
		256	,
		256
	)

Definition at line 647 of file runtimeshader.cpp.

                                                  {
    static constexpr char scale[] =
        "uniform shader child;"
        "half4 main(float2 xy) {"
        "    return child.eval(xy*0.1);"
        "}";
 
    SkPaint p;
    p.setColor(SK_ColorRED);
    p.setAntiAlias(true);
    p.setStyle(SkPaint::kStroke_Style);
    p.setStrokeWidth(1);
 
    auto surf = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(100, 100));
    surf->getCanvas()->drawLine(0, 0, 100, 100, p);
    auto shader = surf->makeImageSnapshot()->makeShader(SkSamplingOptions(SkFilterMode::kLinear));
 
    SkRuntimeShaderBuilder builder(SkRuntimeEffect::MakeForShader(SkString(scale)).effect);
    builder.child("child") = shader;
    p.setShader(builder.makeShader());
 
    canvas->drawPaint(p);
}

DEF_SIMPLE_GM() [2/6]

DEF_SIMPLE_GM	(	lit_shader_linear_rt	,
		canvas	,
		512	,
		256
	)

Definition at line 831 of file runtimeshader.cpp.

                                                      {
    // First, make an offscreen surface, so we can control the destination color space:
    auto surfInfo = SkImageInfo::Make(512, 256,
                                      kN32_SkColorType,
                                      kPremul_SkAlphaType,
                                      SkColorSpace::MakeSRGB());
    auto surface = canvas->makeSurface(surfInfo);
    if (!surface) {
        surface = SkSurfaces::Raster(surfInfo);
    }
 
    auto draw_shader = [](int x, int y, sk_sp<SkShader> shader, SkCanvas* canvas) {
        SkPaint p;
        p.setShader(shader);
 
        canvas->save();
        canvas->translate(x, y);
        canvas->clipRect({0, 0, 256, 256});
        canvas->drawPaint(p);
        canvas->restore();
    };
 
    // We draw two lit spheres - one does math in the working space (so gamma-encoded). The second
    // works in linear space, then converts to sRGB. This produces (more accurate) sharp falloff:
    draw_shader(0, 0, lit_shader(normal_map_shader()), surface->getCanvas());
    draw_shader(256, 0, lit_shader_linear(normal_map_shader()), surface->getCanvas());
 
    // Now draw the offscreen surface back to our original canvas:
    canvas->drawImage(surface->makeImageSnapshot(), 0, 0);
}

DEF_SIMPLE_GM() [3/6]

DEF_SIMPLE_GM	(	local_matrix_shader_rt	,
		canvas	,
		256	,
		256
	)

Definition at line 863 of file runtimeshader.cpp.

                                                        {
    SkString passthrough(R"(
        uniform shader s;
        half4 main(float2 p) { return s.eval(p); }
    )");
    auto [rte, error] = SkRuntimeEffect::MakeForShader(passthrough, {});
    if (!rte) {
        SkDebugf("%s\n", error.c_str());
        return;
    }
 
    auto image = ToolUtils::GetResourceAsImage("images/mandrill_128.png");
    auto imgShader = image->makeShader(SkFilterMode::kNearest);
 
    auto r = SkRect::MakeWH(image->width(), image->height());
 
    auto lm = SkMatrix::RotateDeg(90.f, {image->width()/2.f, image->height()/2.f});
 
    SkPaint paint;
 
    // image
    paint.setShader(imgShader);
    canvas->drawRect(r, paint);
 
    // passthrough(image)
    canvas->save();
    canvas->translate(image->width(), 0);
    paint.setShader(rte->makeShader(/* uniforms= */ nullptr, &imgShader, /* childCount= */ 1));
    canvas->drawRect(r, paint);
    canvas->restore();
 
    // localmatrix(image)
    canvas->save();
    canvas->translate(0, image->height());
    paint.setShader(imgShader->makeWithLocalMatrix(lm));
    canvas->drawRect(r, paint);
    canvas->restore();
 
    // localmatrix(passthrough(image)) This was the bug.
    canvas->save();
    canvas->translate(image->width(), image->height());
    paint.setShader(rte->makeShader(/* uniforms= */ nullptr, &imgShader, /* childCount= */ 1)
                            ->makeWithLocalMatrix(lm));
    canvas->drawRect(r, paint);
    canvas->restore();
}

DEF_SIMPLE_GM() [4/6]

DEF_SIMPLE_GM	(	null_child_rt	,
		canvas	,
		150	,
		100
	)

Definition at line 910 of file runtimeshader.cpp.

                                               {
    using ChildPtr = SkRuntimeEffect::ChildPtr;
 
    // Every swatch should evaluate to the same shade of purple.
    // Paint with a shader evaluating a null shader.
    // Point passed to eval() is ignored; transparent black is returned.
    {
        const SkString kEvalShader{R"(
            uniform shader s;
            half4 main(float2 p) { return s.eval(p) + half4(0.5, 0, 0.5, 1); }
        )"};
        auto [rtShader, error] = SkRuntimeEffect::MakeForShader(kEvalShader);
        SkASSERT(rtShader);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkShader>{nullptr}}};
        paint.setShader(rtShader->makeShader(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0xFF, 0x00));  // green (ignored)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }
    // Paint with a shader evaluating a null color filter.
    // Color passed to eval() is returned; paint color is ignored.
    {
        const SkString kEvalColorFilter{R"(
            uniform colorFilter cf;
            half4 main(float2 p) { return cf.eval(half4(0.5, 0, 0.5, 1)); }
        )"};
        auto [rtShader, error] = SkRuntimeEffect::MakeForShader(kEvalColorFilter);
        SkASSERT(rtShader);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkColorFilter>{nullptr}}};
        paint.setShader(rtShader->makeShader(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));  // green (does not contribute)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }
    // Paint with a shader evaluating a null blender.
    // Colors passed to eval() are blended via src-over; paint color is ignored.
    {
        const SkString kEvalBlender{R"(
            uniform blender b;
            half4 main(float2 p) { return b.eval(half4(0.5, 0, 0, 0.5), half4(0, 0, 1, 1)); }
        )"};
        auto [rtShader, error] = SkRuntimeEffect::MakeForShader(kEvalBlender);
        SkASSERT(rtShader);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkBlender>{nullptr}}};
        paint.setShader(rtShader->makeShader(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));  // green (does not contribute)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }
 
    canvas->translate(-150, 50);
 
    // Paint with a color filter evaluating a null shader.
    // Point passed to eval() is ignored; transparent black is returned.
    {
        const SkString kEvalShader{R"(
            uniform shader s;
            half4 main(half4 c) { return s.eval(float2(0)) + half4(0.5, 0, 0.5, 1); }
        )"};
        auto [rtFilter, error] = SkRuntimeEffect::MakeForColorFilter(kEvalShader);
        SkASSERT(rtFilter);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkShader>{nullptr}}};
        paint.setColorFilter(rtFilter->makeColorFilter(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0xFF, 0x00));  // green (ignored)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }
    // Paint with a color filter evaluating a null color filter.
    // Color passed to eval() is returned; paint color is ignored.
    {
        const SkString kEvalColorFilter{R"(
            uniform colorFilter cf;
            half4 main(half4 c) { return cf.eval(half4(0.5, 0, 0.5, 1)); }
        )"};
        auto [rtFilter, error] = SkRuntimeEffect::MakeForColorFilter(kEvalColorFilter);
        SkASSERT(rtFilter);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkColorFilter>{nullptr}}};
        paint.setColorFilter(rtFilter->makeColorFilter(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));  // green (does not contribute)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }

DEF_SIMPLE_GM() [5/6]

DEF_SIMPLE_GM	(	paint_alpha_normals_rt	,
		canvas	,
		512	,
		512
	)

Definition at line 754 of file runtimeshader.cpp.

                                                       {
    // Various draws, with non-opaque paint alpha. This demonstrates several issues around how
    // paint alpha is applied differently on CPU (globally, after all shaders) and GPU (per shader,
    // inconsistently). See: skbug.com/11942
    //
    // When this works, it will be a demo of applying paint alpha to fade out a complex effect.
    auto draw_shader = [=](int x, int y, sk_sp<SkShader> shader) {
        SkPaint p;
        p.setAlpha(164);
        p.setShader(shader);
 
        canvas->save();
        canvas->translate(x, y);
        canvas->clipRect({0, 0, 256, 256});
        canvas->drawPaint(p);
        canvas->restore();
    };
 
    draw_shader(0, 0, normal_map_shader());
    draw_shader(0, 256, normal_map_image_shader());
 
    draw_shader(256, 0, lit_shader(normal_map_shader()));
    draw_shader(256, 256, lit_shader(normal_map_image_shader()));
}

DEF_SIMPLE_GM() [6/6]

DEF_SIMPLE_GM	(	raw_image_shader_normals_rt	,
		canvas	,
		768	,
		512
	)

Definition at line 779 of file runtimeshader.cpp.

                                                             {
    // Demonstrates the utility of SkImage::makeRawShader, for non-color child shaders.
 
    // First, make an offscreen surface, so we can control the destination color space:
    auto surfInfo = SkImageInfo::Make(512, 512,
                                      kN32_SkColorType,
                                      kPremul_SkAlphaType,
                                      SkColorSpace::MakeSRGB()->makeColorSpin());
    auto surface = canvas->makeSurface(surfInfo);
    if (!surface) {
        surface = SkSurfaces::Raster(surfInfo);
    }
 
    auto draw_shader = [](int x, int y, sk_sp<SkShader> shader, SkCanvas* canvas) {
        SkPaint p;
        p.setShader(shader);
 
        canvas->save();
        canvas->translate(x, y);
        canvas->clipRect({0, 0, 256, 256});
        canvas->drawPaint(p);
        canvas->restore();
    };
 
    sk_sp<SkShader> colorNormals = normal_map_image_shader(),
                    rawNormals = normal_map_raw_image_shader();
 
    // Draw our normal map as colors (will be color-rotated), and raw (untransformed)
    draw_shader(0, 0, colorNormals, surface->getCanvas());
    draw_shader(0, 256, rawNormals, surface->getCanvas());
 
    // Now draw our lighting shader using the normal and raw versions of the normals as children.
    // The top image will have the normals rotated (incorrectly), so the lighting is very dark.
    draw_shader(256, 0, lit_shader(colorNormals), surface->getCanvas());
    draw_shader(256, 256, lit_shader(rawNormals), surface->getCanvas());
 
    // Now draw the offscreen surface back to our original canvas. If we do this naively, the image
    // will be un-transformed back to the canvas' color space. That will have the effect of undoing
    // the color spin on the upper-left, and APPLYING a color-spin on the bottom left. To preserve
    // the intent of this GM (and make it draw consistently whether or not the original surface has
    // a color space attached), we reinterpret the offscreen image as being in sRGB:
    canvas->drawImage(
            surface->makeImageSnapshot()->reinterpretColorSpace(SkColorSpace::MakeSRGB()), 0, 0);
 
    // Finally, to demonstrate that raw unpremul image shaders don't premul, draw lighting two more
    // times, with an unpremul normal map (containing ZERO in the alpha channel). THe top will
    // premultiply the normals, resulting in totally dark lighting. The bottom will retain the RGB
    // encoded normals, even with zero alpha:
    draw_shader(512, 0, lit_shader(normal_map_unpremul_image_shader()), canvas);
    draw_shader(512, 256, lit_shader(normal_map_raw_unpremul_image_shader()), canvas);
}

DEF_SIMPLE_GM_CAN_FAIL() [1/2]

DEF_SIMPLE_GM_CAN_FAIL	(	alpha_image_shader_rt	,
		canvas	,
		errorMsg	,
		350	,
		50
	)

Definition at line 1044 of file runtimeshader.cpp.

                                                                               {});
    SkASSERT(shader);
 
    SkPaint paint;
    paint.setShader(shader);
 
    for (int i = 0; i < 3; ++i) {
        canvas->drawRect({0, 0, 50, 50}, paint);
        canvas->translate(50, 0);
    }
 
    return skiagm::DrawResult::kOk;
}
 
sk_sp<SkShader> paint_color_shader() {
    SkBitmap bmp;
    bmp.allocPixels(SkImageInfo::Make(1, 1, kAlpha_8_SkColorType, kPremul_SkAlphaType));
    bmp.eraseColor(SK_ColorWHITE);
    return bmp.makeShader(SkFilterMode::kNearest);
}
 
DEF_SIMPLE_GM_CAN_FAIL(alpha_image_shader_rt, canvas, errorMsg, 350, 50) {
    if (!canvas->getSurface()) {
        // The only backend that really fails is DDL (because the color filter fails to evaluate on
        // the CPU when we do paint optimization). We can't identify DDL separate from other
        // recording backends, so skip this GM for all of them:
        *errorMsg = "Not supported in recording/DDL mode";
        return skiagm::DrawResult::kSkip;
    }
 
    // Skia typically applies the paint color (or input color, for more complex GPU-FP trees)
    // to alpha-only images. This is useful in trivial cases, but surprising and inconsistent in
    // more complex situations, especially when using SkSL.
    //
    // This GM checks that we suppress the paint-color tinting from SkSL, and always get {0,0,0,a}.
    auto checkerboard = ToolUtils::create_checkerboard_shader(SK_ColorBLACK, SK_ColorWHITE, 4);
    auto paint_shader = paint_color_shader();
    SkRuntimeEffect::ChildPtr children[1] = { paint_shader };
 
    SkPaint paint;
    paint.setColor({0.5f, 0, 0.5f, 1.0f});
 
    auto rect = [&]() {
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    };
 
    // Two simple cases: just paint color, then the "paint color" shader.
    // These should both be PURPLE
    rect();
 
    paint.setShader(paint_shader);
    rect();
 
    // All remaining cases should be BLACK
 
    // Shader that evaluates the "paint color" shader.
    // For color-filter and blender, we test them with and without an actual SkShader on the paint.
    // These should all be BLACK
    paint.setShader(
            SkRuntimeEffect::MakeForShader(SkString("uniform shader s;"
                                                    "half4 main(float2 p) { return s.eval(p); }"))
                    .effect->makeShader(/* uniforms= */ nullptr, children));
    rect();
 
    // Color-filter that evaluates the "paint color" shader, with and without a shader on the paint
    paint.setShader(nullptr);
    paint.setColorFilter(SkRuntimeEffect::MakeForColorFilter(
                                 SkString("uniform shader s;"
                                          "half4 main(half4 color) { return s.eval(float2(0)); }"))

DEF_SIMPLE_GM_CAN_FAIL() [2/2]

DEF_SIMPLE_GM_CAN_FAIL	(	deferred_shader_rt	,
		canvas	,
		errorMsg	,
		150	,
		50
	)

Definition at line 1003 of file runtimeshader.cpp.

    {
        const SkString kEvalBlender{R"(
            uniform blender b;
            half4 main(half4 c) { return b.eval(half4(0.5, 0, 0, 0.5), half4(0, 0, 1, 1)); }
        )"};
        auto [rtFilter, error] = SkRuntimeEffect::MakeForColorFilter(kEvalBlender);
        SkASSERT(rtFilter);
 
        SkPaint paint;
        ChildPtr children[1] = {ChildPtr{sk_sp<SkBlender>{nullptr}}};
        paint.setColorFilter(rtFilter->makeColorFilter(/*uniforms=*/nullptr, children));
        paint.setColor(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));  // green (does not contribute)
        canvas->drawRect({0, 0, 48, 48}, paint);
        canvas->translate(50, 0);
    }
}
 
DEF_SIMPLE_GM_CAN_FAIL(deferred_shader_rt, canvas, errorMsg, 150, 50) {
    // Skip this GM on recording devices. It actually works okay on serialize-8888, but pic-8888
    // does not. Ultimately, behavior on CPU is potentially strange (especially with SkRP), because
    // SkRP will build the shader more than once per draw.
    if (canvas->imageInfo().colorType() == kUnknown_SkColorType) {
        return skiagm::DrawResult::kSkip;
    }
 
    const SkString kShader{R"(
        uniform half4 color;
        half4 main(float2 p) { return color; }
    )"};
    auto [effect, error] = SkRuntimeEffect::MakeForShader(kShader);
    SkASSERT(effect);
 

lit_shader()

static sk_sp< SkShader > lit_shader ( sk_sp< SkShader >  normals )

static

Definition at line 726 of file runtimeshader.cpp.

                                                           {
    // Simple N-dot-L against a fixed, directional light:
    static const char* kSrc = R"(
        uniform shader normals;
        half4 main(vec2 p) {
            vec3 n = normalize(normals.eval(p).xyz * 2 - 1);
            vec3 l = normalize(vec3(1, -1, 1));
            return saturate(dot(n, l)).xxx1;
        }
    )";
    auto effect = SkRuntimeEffect::MakeForShader(SkString(kSrc)).effect;
    return effect->makeShader(/* uniforms= */ nullptr, &normals, /* childCount= */ 1);
}

lit_shader_linear()

static sk_sp< SkShader > lit_shader_linear ( sk_sp< SkShader >  normals )

static

Definition at line 740 of file runtimeshader.cpp.

                                                                  {
    // Simple N-dot-L against a fixed, directional light, done in linear space:
    static const char* kSrc = R"(
        uniform shader normals;
        half4 main(vec2 p) {
            vec3 n = normalize(normals.eval(p).xyz * 2 - 1);
            vec3 l = normalize(vec3(1, -1, 1));
            return fromLinearSrgb(saturate(dot(n, l)).xxx).xxx1;
        }
    )";
    auto effect = SkRuntimeEffect::MakeForShader(SkString(kSrc)).effect;
    return effect->makeShader(/* uniforms= */ nullptr, &normals, /* childCount= */ 1);
}

make_shader()

static sk_sp< SkShader > make_shader ( sk_sp< SkImage >  img, SkISize  size  )

static

Definition at line 92 of file runtimeshader.cpp.

                                                                     {
    SkMatrix scale = SkMatrix::Scale(size.width()  / (float)img->width(),
                                     size.height() / (float)img->height());
    return img->makeShader(SkSamplingOptions(), scale);
}

make_threshold()

static sk_sp< SkShader > make_threshold ( SkISize  size )

static

Definition at line 98 of file runtimeshader.cpp.

                                                    {
    auto info = SkImageInfo::Make(size.width(), size.height(), kAlpha_8_SkColorType,
                                  kPremul_SkAlphaType);
    auto surf = SkSurfaces::Raster(info);
    auto canvas = surf->getCanvas();
 
    const SkScalar rad = 50;
    SkColor colors[] = {SK_ColorBLACK, 0};
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setShader(SkGradientShader::MakeRadial({0,0}, rad, colors, nullptr, 2, SkTileMode::kClamp));
 
    SkPaint layerPaint;
    const SkScalar sigma = 16.0f;
    layerPaint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr));
    canvas->saveLayer(nullptr, &layerPaint);
 
    SkRandom rand;
    for (int i = 0; i < 25; ++i) {
        SkScalar x = rand.nextF() * size.width();
        SkScalar y = rand.nextF() * size.height();
        canvas->save();
        canvas->translate(x, y);
        canvas->drawCircle(0, 0, rad, paint);
        canvas->restore();
    }
 
    canvas->restore();  // apply the blur
 
    return surf->makeImageSnapshot()->makeShader(SkSamplingOptions());
}

normal_map_image()

static sk_sp< SkImage > normal_map_image ( )

static

Definition at line 685 of file runtimeshader.cpp.

                                         {
    // Above, baked into an image:
    auto info = SkImageInfo::Make(256, 256, kN32_SkColorType, kPremul_SkAlphaType);
    auto surface = SkSurfaces::Raster(info);
    SkPaint p;
    p.setShader(normal_map_shader());
    surface->getCanvas()->drawPaint(p);
    return surface->makeImageSnapshot();
}

normal_map_image_shader()

static sk_sp< SkShader > normal_map_image_shader ( )

static

Definition at line 695 of file runtimeshader.cpp.

                                                 {
    return normal_map_image()->makeShader(SkFilterMode::kNearest);
}

normal_map_raw_image_shader()

static sk_sp< SkShader > normal_map_raw_image_shader ( )

static

Definition at line 699 of file runtimeshader.cpp.

                                                     {
    return normal_map_image()->makeRawShader(SkFilterMode::kNearest);
}

normal_map_raw_unpremul_image_shader()

static sk_sp< SkShader > normal_map_raw_unpremul_image_shader ( )

static

Definition at line 722 of file runtimeshader.cpp.

                                                              {
    return normal_map_unpremul_image()->makeRawShader(SkFilterMode::kNearest);
}

normal_map_shader()

static sk_sp< SkShader > normal_map_shader ( )

static

Definition at line 671 of file runtimeshader.cpp.

                                           {
    // Produces a hemispherical normal:
    static const char* kSrc = R"(
        half4 main(vec2 p) {
            p = (p / 256) * 2 - 1;
            float p2 = dot(p, p);
            vec3 v = (p2 > 1) ? vec3(0, 0, 1) : vec3(p, sqrt(1 - p2));
            return (v * 0.5 + 0.5).xyz1;
        }
    )";
    auto effect = SkRuntimeEffect::MakeForShader(SkString(kSrc)).effect;
    return effect->makeShader(nullptr, {});
}

normal_map_unpremul_image()

static sk_sp< SkImage > normal_map_unpremul_image ( )

static

Definition at line 703 of file runtimeshader.cpp.

                                                  {
    auto image = normal_map_image();
    SkPixmap pm;
    SkAssertResult(image->peekPixels(&pm));
    SkBitmap bmp;
    bmp.allocPixels(image->imageInfo().makeAlphaType(kUnpremul_SkAlphaType));
    // Copy all pixels over, but set alpha to 0
    for (int y = 0; y < pm.height(); y++) {
        for (int x = 0; x < pm.width(); x++) {
            *bmp.getAddr32(x, y) = *pm.addr32(x, y) & 0x00FFFFFF;
        }
    }
    return bmp.asImage();
}

normal_map_unpremul_image_shader()

static sk_sp< SkShader > normal_map_unpremul_image_shader ( )

static

Definition at line 718 of file runtimeshader.cpp.

                                                          {
    return normal_map_unpremul_image()->makeShader(SkFilterMode::kNearest);
}

paint_color_shader()

sk_sp< SkShader > paint_color_shader

(

)

Definition at line 1037 of file runtimeshader.cpp.

                                                                                           {
        auto result = SkData::MakeWithCopy(&color, sizeof(color));
        color = {color.fB, color.fR, color.fG, color.fA};
        return result;
    };