Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2019 Google LLC |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "gm/gm.h" |
| 9 | #include "include/core/SkCanvas.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 10 | #include "include/core/SkData.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 11 | #include "include/core/SkPaint.h" |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 12 | #include "include/core/SkRRect.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 13 | #include "include/core/SkSize.h" |
| 14 | #include "include/core/SkString.h" |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 15 | #include "include/core/SkSurface.h" |
| 16 | #include "include/effects/SkGradientShader.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 17 | #include "include/effects/SkImageFilters.h" |
Brian Osman | ee426f2 | 2020-01-02 11:55:24 -0500 | [diff] [blame] | 18 | #include "include/effects/SkRuntimeEffect.h" |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 19 | #include "include/utils/SkRandom.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 20 | #include "tools/Resources.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 21 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 22 | enum RT_Flags { |
| 23 | kAnimate_RTFlag = 0x1, |
| 24 | kBench_RTFlag = 0x2, |
| 25 | }; |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 26 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 27 | class RuntimeShaderGM : public skiagm::GM { |
| 28 | public: |
| 29 | RuntimeShaderGM(const char* name, SkISize size, const char* sksl, uint32_t flags = 0) |
| 30 | : fName(name), fSize(size), fFlags(flags), fSkSL(sksl) {} |
| 31 | |
| 32 | void onOnceBeforeDraw() override { |
Brian Osman | f6123f1 | 2021-04-15 13:52:43 -0400 | [diff] [blame^] | 33 | auto [effect, error] = SkRuntimeEffect::MakeForShader(fSkSL); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 34 | if (!effect) { |
| 35 | SkDebugf("RuntimeShader error: %s\n", error.c_str()); |
| 36 | } |
| 37 | fEffect = std::move(effect); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 38 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 39 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 40 | bool runAsBench() const override { return SkToBool(fFlags & kBench_RTFlag); } |
| 41 | SkString onShortName() override { return fName; } |
| 42 | SkISize onISize() override { return fSize; } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 43 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 44 | bool onAnimate(double nanos) override { |
| 45 | fSecs = nanos / (1000 * 1000 * 1000); |
| 46 | return SkToBool(fFlags & kAnimate_RTFlag); |
| 47 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 48 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 49 | protected: |
| 50 | SkString fName; |
| 51 | SkISize fSize; |
| 52 | uint32_t fFlags; |
| 53 | float fSecs = 0.0f; |
| 54 | |
| 55 | SkString fSkSL; |
| 56 | sk_sp<SkRuntimeEffect> fEffect; |
| 57 | }; |
| 58 | |
| 59 | class SimpleRT : public RuntimeShaderGM { |
| 60 | public: |
| 61 | SimpleRT() : RuntimeShaderGM("runtime_shader", {512, 256}, R"( |
| 62 | uniform half4 gColor; |
| 63 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 64 | half4 main(float2 p) { |
Brian Osman | b25e6e1 | 2020-09-14 14:44:42 -0400 | [diff] [blame] | 65 | return half4(p*(1.0/255), gColor.b, 1); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 66 | } |
| 67 | )", kBench_RTFlag) {} |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 68 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 69 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 70 | SkRuntimeShaderBuilder builder(fEffect); |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 71 | |
| 72 | SkMatrix localM; |
| 73 | localM.setRotate(90, 128, 128); |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 74 | builder.uniform("gColor") = SkColor4f{1, 0, 0, 1}; |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 75 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 76 | SkPaint p; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 77 | p.setShader(builder.makeShader(&localM, true)); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 78 | canvas->drawRect({0, 0, 256, 256}, p); |
| 79 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 80 | }; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 81 | DEF_GM(return new SimpleRT;) |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 82 | |
| 83 | static sk_sp<SkShader> make_shader(sk_sp<SkImage> img, SkISize size) { |
Mike Reed | 1f60733 | 2020-05-21 12:11:27 -0400 | [diff] [blame] | 84 | SkMatrix scale = SkMatrix::Scale(size.width() / (float)img->width(), |
| 85 | size.height() / (float)img->height()); |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 86 | return img->makeShader(SkSamplingOptions(), scale); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 87 | } |
| 88 | |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 89 | static sk_sp<SkShader> make_threshold(SkISize size) { |
| 90 | auto info = SkImageInfo::Make(size.width(), size.height(), kAlpha_8_SkColorType, |
| 91 | kPremul_SkAlphaType); |
| 92 | auto surf = SkSurface::MakeRaster(info); |
| 93 | auto canvas = surf->getCanvas(); |
| 94 | |
| 95 | const SkScalar rad = 50; |
| 96 | SkColor colors[] = {SK_ColorBLACK, 0}; |
| 97 | SkPaint paint; |
| 98 | paint.setAntiAlias(true); |
| 99 | paint.setShader(SkGradientShader::MakeRadial({0,0}, rad, colors, nullptr, 2, SkTileMode::kClamp)); |
| 100 | |
| 101 | SkPaint layerPaint; |
| 102 | const SkScalar sigma = 16.0f; |
| 103 | layerPaint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr)); |
| 104 | canvas->saveLayer(nullptr, &layerPaint); |
| 105 | |
| 106 | SkRandom rand; |
| 107 | for (int i = 0; i < 25; ++i) { |
| 108 | SkScalar x = rand.nextF() * size.width(); |
| 109 | SkScalar y = rand.nextF() * size.height(); |
| 110 | canvas->save(); |
| 111 | canvas->translate(x, y); |
| 112 | canvas->drawCircle(0, 0, rad, paint); |
| 113 | canvas->restore(); |
| 114 | } |
| 115 | |
| 116 | canvas->restore(); // apply the blur |
| 117 | |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 118 | return surf->makeImageSnapshot()->makeShader(SkSamplingOptions()); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 119 | } |
| 120 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 121 | class ThresholdRT : public RuntimeShaderGM { |
| 122 | public: |
| 123 | ThresholdRT() : RuntimeShaderGM("threshold_rt", {256, 256}, R"( |
Brian Osman | 91292e9 | 2020-11-04 15:40:50 -0500 | [diff] [blame] | 124 | uniform shader before_map; |
| 125 | uniform shader after_map; |
| 126 | uniform shader threshold_map; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 127 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 128 | uniform float cutoff; |
| 129 | uniform float slope; |
| 130 | |
| 131 | float smooth_cutoff(float x) { |
| 132 | x = x * slope + (0.5 - slope * cutoff); |
| 133 | return clamp(x, 0, 1); |
| 134 | } |
| 135 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 136 | half4 main(float2 xy) { |
Brian Osman | cc3d2d2 | 2021-04-16 14:53:24 -0400 | [diff] [blame] | 137 | half4 before = sample(before_map, xy); |
| 138 | half4 after = sample(after_map, xy); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 139 | |
Brian Osman | cc3d2d2 | 2021-04-16 14:53:24 -0400 | [diff] [blame] | 140 | float m = smooth_cutoff(sample(threshold_map, xy).a); |
Brian Osman | b25e6e1 | 2020-09-14 14:44:42 -0400 | [diff] [blame] | 141 | return mix(before, after, m); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 142 | } |
| 143 | )", kAnimate_RTFlag | kBench_RTFlag) {} |
| 144 | |
| 145 | sk_sp<SkShader> fBefore, fAfter, fThreshold; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 146 | |
| 147 | void onOnceBeforeDraw() override { |
| 148 | const SkISize size = {256, 256}; |
| 149 | fThreshold = make_threshold(size); |
| 150 | fBefore = make_shader(GetResourceAsImage("images/mandrill_256.png"), size); |
| 151 | fAfter = make_shader(GetResourceAsImage("images/dog.jpg"), size); |
| 152 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 153 | this->RuntimeShaderGM::onOnceBeforeDraw(); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 154 | } |
| 155 | |
Mike Klein | f8d68fe | 2020-06-18 10:01:31 -0500 | [diff] [blame] | 156 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 157 | SkRuntimeShaderBuilder builder(fEffect); |
| 158 | |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 159 | builder.uniform("cutoff") = sin(fSecs) * 0.55f + 0.5f; |
| 160 | builder.uniform("slope") = 10.0f; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 161 | |
| 162 | builder.child("before_map") = fBefore; |
| 163 | builder.child("after_map") = fAfter; |
| 164 | builder.child("threshold_map") = fThreshold; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 165 | |
| 166 | SkPaint paint; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 167 | paint.setShader(builder.makeShader(nullptr, true)); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 168 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 169 | |
| 170 | auto draw = [&](SkScalar x, SkScalar y, sk_sp<SkShader> shader) { |
| 171 | paint.setShader(shader); |
| 172 | canvas->save(); |
| 173 | canvas->translate(x, y); |
| 174 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 175 | canvas->restore(); |
| 176 | }; |
| 177 | draw(256, 0, fThreshold); |
| 178 | draw( 0, 256, fBefore); |
| 179 | draw(256, 256, fAfter); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 180 | } |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 181 | }; |
| 182 | DEF_GM(return new ThresholdRT;) |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 183 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 184 | class SpiralRT : public RuntimeShaderGM { |
| 185 | public: |
| 186 | SpiralRT() : RuntimeShaderGM("spiral_rt", {512, 512}, R"( |
| 187 | uniform float rad_scale; |
| 188 | uniform float2 in_center; |
| 189 | layout(srgb_unpremul) uniform float4 in_colors0; |
| 190 | layout(srgb_unpremul) uniform float4 in_colors1; |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 191 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 192 | half4 main(float2 p) { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 193 | float2 pp = p - in_center; |
| 194 | float radius = length(pp); |
| 195 | radius = sqrt(radius); |
| 196 | float angle = atan(pp.y / pp.x); |
| 197 | float t = (angle + 3.1415926/2) / (3.1415926); |
| 198 | t += radius * rad_scale; |
| 199 | t = fract(t); |
Brian Osman | b25e6e1 | 2020-09-14 14:44:42 -0400 | [diff] [blame] | 200 | return in_colors0 * (1-t) + in_colors1 * t; |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 201 | } |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 202 | )", kAnimate_RTFlag | kBench_RTFlag) {} |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 203 | |
| 204 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 205 | SkRuntimeShaderBuilder builder(fEffect); |
| 206 | |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 207 | builder.uniform("rad_scale") = std::sin(fSecs * 0.5f + 2.0f) / 5; |
| 208 | builder.uniform("in_center") = SkV2{256, 256}; |
| 209 | builder.uniform("in_colors0") = SkV4{1, 0, 0, 1}; |
| 210 | builder.uniform("in_colors1") = SkV4{0, 1, 0, 1}; |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 211 | |
| 212 | SkPaint paint; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 213 | paint.setShader(builder.makeShader(nullptr, true)); |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 214 | canvas->drawRect({0, 0, 512, 512}, paint); |
| 215 | } |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 216 | }; |
| 217 | DEF_GM(return new SpiralRT;) |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 218 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 219 | class ColorCubeRT : public RuntimeShaderGM { |
| 220 | public: |
| 221 | ColorCubeRT() : RuntimeShaderGM("color_cube_rt", {512, 512}, R"( |
Brian Osman | 91292e9 | 2020-11-04 15:40:50 -0500 | [diff] [blame] | 222 | uniform shader input; |
| 223 | uniform shader color_cube; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 224 | |
| 225 | uniform float rg_scale; |
| 226 | uniform float rg_bias; |
| 227 | uniform float b_scale; |
| 228 | uniform float inv_size; |
| 229 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 230 | half4 main(float2 xy) { |
Brian Osman | cc3d2d2 | 2021-04-16 14:53:24 -0400 | [diff] [blame] | 231 | float4 c = unpremul(sample(input, xy)); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 232 | |
| 233 | // Map to cube coords: |
| 234 | float3 cubeCoords = float3(c.rg * rg_scale + rg_bias, c.b * b_scale); |
| 235 | |
| 236 | // Compute slice coordinate |
| 237 | float2 coords1 = float2((floor(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g); |
| 238 | float2 coords2 = float2(( ceil(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g); |
| 239 | |
| 240 | // Two bilinear fetches, plus a manual lerp for the third axis: |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 241 | half4 color = mix(sample(color_cube, coords1), sample(color_cube, coords2), |
Brian Osman | b25e6e1 | 2020-09-14 14:44:42 -0400 | [diff] [blame] | 242 | fract(cubeCoords.b)); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 243 | |
| 244 | // Premul again |
| 245 | color.rgb *= color.a; |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame] | 246 | |
| 247 | return color; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 248 | } |
| 249 | )") {} |
| 250 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 251 | sk_sp<SkImage> fMandrill, fMandrillSepia, fIdentityCube, fSepiaCube; |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 252 | |
| 253 | void onOnceBeforeDraw() override { |
| 254 | fMandrill = GetResourceAsImage("images/mandrill_256.png"); |
| 255 | fMandrillSepia = GetResourceAsImage("images/mandrill_sepia.png"); |
| 256 | fIdentityCube = GetResourceAsImage("images/lut_identity.png"); |
| 257 | fSepiaCube = GetResourceAsImage("images/lut_sepia.png"); |
| 258 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 259 | this->RuntimeShaderGM::onOnceBeforeDraw(); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 260 | } |
| 261 | |
Brian Osman | 89bf734 | 2020-06-18 17:11:16 -0400 | [diff] [blame] | 262 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 263 | SkRuntimeShaderBuilder builder(fEffect); |
| 264 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 265 | // First we draw the unmodified image, and a copy that was sepia-toned in Photoshop: |
| 266 | canvas->drawImage(fMandrill, 0, 0); |
| 267 | canvas->drawImage(fMandrillSepia, 0, 256); |
| 268 | |
| 269 | // LUT dimensions should be (kSize^2, kSize) |
| 270 | constexpr float kSize = 16.0f; |
| 271 | |
Mike Reed | 5ec2238 | 2021-01-14 21:59:01 -0500 | [diff] [blame] | 272 | const SkSamplingOptions sampling(SkFilterMode::kLinear); |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 273 | |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 274 | builder.uniform("rg_scale") = (kSize - 1) / kSize; |
| 275 | builder.uniform("rg_bias") = 0.5f / kSize; |
| 276 | builder.uniform("b_scale") = kSize - 1; |
| 277 | builder.uniform("inv_size") = 1.0f / kSize; |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 278 | |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 279 | builder.child("input") = fMandrill->makeShader(sampling); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 280 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 281 | SkPaint paint; |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 282 | |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 283 | // TODO: Should we add SkImage::makeNormalizedShader() to handle this automatically? |
| 284 | SkMatrix normalize = SkMatrix::Scale(1.0f / (kSize * kSize), 1.0f / kSize); |
| 285 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 286 | // Now draw the image with an identity color cube - it should look like the original |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 287 | builder.child("color_cube") = fIdentityCube->makeShader(sampling, normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 288 | paint.setShader(builder.makeShader(nullptr, true)); |
| 289 | canvas->translate(256, 0); |
| 290 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 291 | |
| 292 | // ... and with a sepia-tone color cube. This should match the sepia-toned image. |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 293 | builder.child("color_cube") = fSepiaCube->makeShader(sampling, normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 294 | paint.setShader(builder.makeShader(nullptr, true)); |
| 295 | canvas->translate(0, 256); |
| 296 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 297 | } |
| 298 | }; |
| 299 | DEF_GM(return new ColorCubeRT;) |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 300 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 301 | class DefaultColorRT : public RuntimeShaderGM { |
| 302 | public: |
| 303 | DefaultColorRT() : RuntimeShaderGM("default_color_rt", {512, 256}, R"( |
Brian Osman | 91292e9 | 2020-11-04 15:40:50 -0500 | [diff] [blame] | 304 | uniform shader input; |
Brian Osman | f6123f1 | 2021-04-15 13:52:43 -0400 | [diff] [blame^] | 305 | half4 main(float2 xy) { |
| 306 | return sample(input, xy); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 307 | } |
| 308 | )") {} |
| 309 | |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 310 | sk_sp<SkImage> fMandrill; |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 311 | |
| 312 | void onOnceBeforeDraw() override { |
| 313 | fMandrill = GetResourceAsImage("images/mandrill_256.png"); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 314 | this->RuntimeShaderGM::onOnceBeforeDraw(); |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 315 | } |
| 316 | |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 317 | void onDraw(SkCanvas* canvas) override { |
| 318 | SkRuntimeShaderBuilder builder(fEffect); |
| 319 | |
| 320 | // First, we leave the child as null, so sampling it returns the default (paint) color |
| 321 | SkPaint paint; |
| 322 | paint.setColor4f({ 0.25f, 0.75f, 0.75f, 1.0f }); |
| 323 | paint.setShader(builder.makeShader(nullptr, false)); |
| 324 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 325 | |
| 326 | // Now we bind an image shader as the child. This (by convention) scales by the paint alpha |
Mike Reed | 4106819 | 2020-12-09 21:48:52 -0500 | [diff] [blame] | 327 | builder.child("input") = fMandrill->makeShader(SkSamplingOptions()); |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 328 | paint.setColor4f({ 1.0f, 1.0f, 1.0f, 0.5f }); |
| 329 | paint.setShader(builder.makeShader(nullptr, false)); |
| 330 | canvas->translate(256, 0); |
| 331 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 332 | |
| 333 | } |
| 334 | }; |
| 335 | DEF_GM(return new DefaultColorRT;) |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 336 | |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 337 | // Emits coverage for a rounded rectangle whose corners are superellipses defined by the boundary: |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 338 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 339 | // x^n + y^n == 1 |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 340 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 341 | // Where x and y are normalized, clamped coordinates ranging from 0..1 inside the nearest corner's |
| 342 | // bounding box. |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 343 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 344 | // See: https://en.wikipedia.org/wiki/Superellipse |
| 345 | class ClipSuperRRect : public RuntimeShaderGM { |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 346 | public: |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 347 | ClipSuperRRect(const char* name, float power) : RuntimeShaderGM(name, {500, 500}, R"( |
| 348 | uniform float power_minus1; |
| 349 | uniform float2 stretch_factor; |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 350 | uniform float2x2 derivatives; |
| 351 | half4 main(float2 xy) { |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 352 | xy = max(abs(xy) + stretch_factor, 0); |
| 353 | float2 exp_minus1 = pow(xy, power_minus1.xx); // If power == 3.5: xy * xy * sqrt(xy) |
| 354 | float f = dot(exp_minus1, xy) - 1; // f = x^n + y^n - 1 |
| 355 | float2 grad = exp_minus1 * derivatives; |
| 356 | float fwidth = abs(grad.x) + abs(grad.y) + 1e-12; // 1e-12 to avoid a divide by zero. |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 357 | return half4(saturate(.5 - f/fwidth)); // Approx coverage by riding the gradient to f=0. |
| 358 | } |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 359 | )"), fPower(power) {} |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 360 | |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 361 | void drawSuperRRect(SkCanvas* canvas, const SkRect& superRRect, float radX, float radY, |
| 362 | SkColor color) { |
| 363 | SkPaint paint; |
| 364 | paint.setColor(color); |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 365 | |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 366 | if (fPower == 2) { |
| 367 | // Draw a normal round rect for the sake of testing. |
| 368 | SkRRect rrect = SkRRect::MakeRectXY(superRRect, radX, radY); |
| 369 | paint.setAntiAlias(true); |
| 370 | canvas->drawRRect(rrect, paint); |
| 371 | return; |
| 372 | } |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 373 | |
| 374 | SkRuntimeShaderBuilder builder(fEffect); |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 375 | builder.uniform("power_minus1") = fPower - 1; |
| 376 | |
| 377 | // Size the corners such that the "apex" of our "super" rounded corner is in the same |
| 378 | // location that the apex of a circular rounded corner would be with the given radii. We |
| 379 | // define the apex as the point on the rounded corner that is 45 degrees between the |
| 380 | // horizontal and vertical edges. |
| 381 | float scale = (1 - SK_ScalarRoot2Over2) / (1 - exp2f(-1/fPower)); |
| 382 | float cornerWidth = radX * scale; |
| 383 | float cornerHeight = radY * scale; |
| 384 | cornerWidth = std::min(cornerWidth, superRRect.width() * .5f); |
| 385 | cornerHeight = std::min(cornerHeight, superRRect.height() * .5f); |
| 386 | // The stretch factor controls how long the flat edge should be between rounded corners. |
| 387 | builder.uniform("stretch_factor") = SkV2{1 - superRRect.width()*.5f / cornerWidth, |
| 388 | 1 - superRRect.height()*.5f / cornerHeight}; |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 389 | |
| 390 | // Calculate a 2x2 "derivatives" matrix that the shader will use to find the gradient. |
| 391 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 392 | // f = s^n + t^n - 1 [s,t are "super" rounded corner coords in normalized 0..1 space] |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 393 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 394 | // gradient = [df/dx df/dy] = [ns^(n-1) nt^(n-1)] * |ds/dx ds/dy| |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 395 | // |dt/dx dt/dy| |
| 396 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 397 | // = [s^(n-1) t^(n-1)] * |n 0| * |ds/dx ds/dy| |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 398 | // |0 n| |dt/dx dt/dy| |
| 399 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 400 | // = [s^(n-1) t^(n-1)] * |2n/cornerWidth 0| * mat2x2(canvasMatrix)^-1 |
| 401 | // |0 2n/cornerHeight| |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 402 | // |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 403 | // = [s^(n-1) t^(n-1)] * "derivatives" |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 404 | // |
| 405 | const SkMatrix& M = canvas->getTotalMatrix(); |
| 406 | float a=M.getScaleX(), b=M.getSkewX(), c=M.getSkewY(), d=M.getScaleY(); |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 407 | float determinant = a*d - b*c; |
| 408 | float dx = fPower / (cornerWidth * determinant); |
| 409 | float dy = fPower / (cornerHeight * determinant); |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 410 | builder.uniform("derivatives") = SkV4{d*dx, -c*dy, -b*dx, a*dy}; |
| 411 | |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 412 | // This matrix will be inverted by the effect system, giving a matrix that converts local |
| 413 | // coordinates to (almost) coner coordinates. To get the rest of the way to the nearest |
| 414 | // corner's space, the shader will have to take the absolute value, add the stretch_factor, |
| 415 | // then clamp above zero. |
| 416 | SkMatrix cornerToLocal; |
| 417 | cornerToLocal.setScaleTranslate(cornerWidth, cornerHeight, superRRect.centerX(), |
| 418 | superRRect.centerY()); |
| 419 | canvas->clipShader(builder.makeShader(&cornerToLocal, false)); |
| 420 | |
| 421 | // Bloat the outer edges of the rect we will draw so it contains all the antialiased pixels. |
| 422 | // Bloat by a full pixel instead of half in case Skia is in a mode that draws this rect with |
| 423 | // unexpected AA of its own. |
| 424 | float inverseDet = 1 / fabsf(determinant); |
| 425 | float bloatX = (fabsf(d) + fabsf(c)) * inverseDet; |
| 426 | float bloatY = (fabsf(b) + fabsf(a)) * inverseDet; |
| 427 | canvas->drawRect(superRRect.makeOutset(bloatX, bloatY), paint); |
| 428 | } |
| 429 | |
| 430 | void onDraw(SkCanvas* canvas) override { |
| 431 | SkRandom rand(2); |
| 432 | |
| 433 | canvas->save(); |
| 434 | canvas->translate(canvas->imageInfo().width() / 2.f, canvas->imageInfo().height() / 2.f); |
| 435 | |
| 436 | canvas->save(); |
| 437 | canvas->rotate(21); |
| 438 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(-5, 25, 175, 100), 50, 30, |
| 439 | rand.nextU() | 0xff808080); |
| 440 | canvas->restore(); |
| 441 | |
| 442 | canvas->save(); |
| 443 | canvas->rotate(94); |
| 444 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(95, 75, 125, 100), 30, 30, |
| 445 | rand.nextU() | 0xff808080); |
| 446 | canvas->restore(); |
| 447 | |
| 448 | canvas->save(); |
| 449 | canvas->rotate(132); |
| 450 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(0, 75, 150, 100), 40, 30, |
| 451 | rand.nextU() | 0xff808080); |
| 452 | canvas->restore(); |
| 453 | |
| 454 | canvas->save(); |
| 455 | canvas->rotate(282); |
| 456 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(15, -20, 100, 100), 20, 20, |
| 457 | rand.nextU() | 0xff808080); |
| 458 | canvas->restore(); |
| 459 | |
| 460 | canvas->save(); |
| 461 | canvas->rotate(0); |
| 462 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(140, -50, 90, 110), 25, 25, |
| 463 | rand.nextU() | 0xff808080); |
| 464 | canvas->restore(); |
| 465 | |
| 466 | canvas->save(); |
| 467 | canvas->rotate(-35); |
| 468 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(160, -60, 60, 90), 18, 18, |
| 469 | rand.nextU() | 0xff808080); |
| 470 | canvas->restore(); |
| 471 | |
| 472 | canvas->save(); |
| 473 | canvas->rotate(65); |
| 474 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(220, -120, 60, 90), 18, 18, |
| 475 | rand.nextU() | 0xff808080); |
| 476 | canvas->restore(); |
| 477 | |
| 478 | canvas->save(); |
| 479 | canvas->rotate(265); |
| 480 | this->drawSuperRRect(canvas, SkRect::MakeXYWH(150, -129, 80, 160), 24, 39, |
| 481 | rand.nextU() | 0xff808080); |
| 482 | canvas->restore(); |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 483 | |
| 484 | canvas->restore(); |
| 485 | } |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 486 | |
| 487 | private: |
| 488 | const float fPower; |
Chris Dalton | 4e94fd1 | 2021-03-15 10:16:09 -0600 | [diff] [blame] | 489 | }; |
Chris Dalton | 224e5e4 | 2021-04-16 11:43:39 -0600 | [diff] [blame] | 490 | DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow2", 2);) |
| 491 | // DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow3", 3);) |
| 492 | DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow3.5", 3.5);) |
| 493 | // DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow4", 4);) |
| 494 | // DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow4.5", 4.5);) |
| 495 | // DEF_GM(return new ClipSuperRRect("clip_super_rrect_pow5", 5);) |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 496 | |
| 497 | DEF_SIMPLE_GM(child_sampling_rt, canvas, 256,256) { |
| 498 | static constexpr char scale[] = |
| 499 | "uniform shader child;" |
| 500 | "half4 main(float2 xy) {" |
| 501 | " return sample(child, xy*0.1);" |
| 502 | "}"; |
| 503 | |
| 504 | SkPaint p; |
| 505 | p.setColor(SK_ColorRED); |
| 506 | p.setAntiAlias(true); |
| 507 | p.setStyle(SkPaint::kStroke_Style); |
| 508 | p.setStrokeWidth(1); |
| 509 | |
| 510 | auto surf = SkSurface::MakeRasterN32Premul(100,100); |
| 511 | surf->getCanvas()->drawLine(0, 0, 100, 100, p); |
| 512 | auto shader = surf->makeImageSnapshot()->makeShader(SkSamplingOptions(SkFilterMode::kLinear)); |
| 513 | |
Brian Osman | f6123f1 | 2021-04-15 13:52:43 -0400 | [diff] [blame^] | 514 | SkRuntimeShaderBuilder builder(SkRuntimeEffect::MakeForShader(SkString(scale)).effect); |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 515 | builder.child("child") = shader; |
| 516 | p.setShader(builder.makeShader(nullptr, false)); |
| 517 | |
| 518 | canvas->drawPaint(p); |
| 519 | } |