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" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 12 | #include "include/core/SkSize.h" |
| 13 | #include "include/core/SkString.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 14 | #include "include/effects/SkImageFilters.h" |
Brian Osman | ee426f2 | 2020-01-02 11:55:24 -0500 | [diff] [blame] | 15 | #include "include/effects/SkRuntimeEffect.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 16 | #include "tools/Resources.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 17 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 18 | const char* gProg = R"( |
Brian Osman | c937bc5 | 2019-12-09 12:07:09 -0500 | [diff] [blame] | 19 | uniform half4 gColor; |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 20 | |
Brian Osman | 7353dc5 | 2020-02-07 13:37:12 -0500 | [diff] [blame] | 21 | void main(float2 p, inout half4 color) { |
| 22 | color = half4(half2(p)*(1.0/255), gColor.b, 1); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 23 | } |
| 24 | )"; |
| 25 | |
| 26 | class RuntimeShader : public skiagm::GM { |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 27 | bool runAsBench() const override { return true; } |
| 28 | |
Hal Canary | 594fe85 | 2019-07-18 13:35:49 -0400 | [diff] [blame] | 29 | SkString onShortName() override { return SkString("runtime_shader"); } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 30 | |
Hal Canary | 594fe85 | 2019-07-18 13:35:49 -0400 | [diff] [blame] | 31 | SkISize onISize() override { return {512, 256}; } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 32 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 33 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 3225306 | 2020-02-05 11:37:08 -0500 | [diff] [blame] | 34 | sk_sp<SkRuntimeEffect> gEffect = std::get<0>(SkRuntimeEffect::Make(SkString(gProg))); |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 35 | SkASSERT(gEffect); |
| 36 | |
| 37 | SkMatrix localM; |
| 38 | localM.setRotate(90, 128, 128); |
| 39 | |
| 40 | SkColor4f inputColor = { 1, 0, 0, 1 }; |
| 41 | auto shader = gEffect->makeShader(SkData::MakeWithCopy(&inputColor, sizeof(inputColor)), |
| 42 | nullptr, 0, &localM, true); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 43 | SkPaint p; |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 44 | p.setShader(std::move(shader)); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 45 | canvas->drawRect({0, 0, 256, 256}, p); |
| 46 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 47 | }; |
| 48 | DEF_GM(return new RuntimeShader;) |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 49 | |
| 50 | static sk_sp<SkShader> make_shader(sk_sp<SkImage> img, SkISize size) { |
Mike Reed | 1f60733 | 2020-05-21 12:11:27 -0400 | [diff] [blame] | 51 | SkMatrix scale = SkMatrix::Scale(size.width() / (float)img->width(), |
| 52 | size.height() / (float)img->height()); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 53 | return img->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, &scale); |
| 54 | } |
| 55 | |
| 56 | #include "include/core/SkSurface.h" |
| 57 | #include "include/effects/SkGradientShader.h" |
| 58 | #include "include/utils/SkRandom.h" |
| 59 | |
| 60 | static sk_sp<SkShader> make_threshold(SkISize size) { |
| 61 | auto info = SkImageInfo::Make(size.width(), size.height(), kAlpha_8_SkColorType, |
| 62 | kPremul_SkAlphaType); |
| 63 | auto surf = SkSurface::MakeRaster(info); |
| 64 | auto canvas = surf->getCanvas(); |
| 65 | |
| 66 | const SkScalar rad = 50; |
| 67 | SkColor colors[] = {SK_ColorBLACK, 0}; |
| 68 | SkPaint paint; |
| 69 | paint.setAntiAlias(true); |
| 70 | paint.setShader(SkGradientShader::MakeRadial({0,0}, rad, colors, nullptr, 2, SkTileMode::kClamp)); |
| 71 | |
| 72 | SkPaint layerPaint; |
| 73 | const SkScalar sigma = 16.0f; |
| 74 | layerPaint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr)); |
| 75 | canvas->saveLayer(nullptr, &layerPaint); |
| 76 | |
| 77 | SkRandom rand; |
| 78 | for (int i = 0; i < 25; ++i) { |
| 79 | SkScalar x = rand.nextF() * size.width(); |
| 80 | SkScalar y = rand.nextF() * size.height(); |
| 81 | canvas->save(); |
| 82 | canvas->translate(x, y); |
| 83 | canvas->drawCircle(0, 0, rad, paint); |
| 84 | canvas->restore(); |
| 85 | } |
| 86 | |
| 87 | canvas->restore(); // apply the blur |
| 88 | |
| 89 | return surf->makeImageSnapshot()->makeShader(); |
| 90 | } |
| 91 | |
| 92 | class ThresholdRT : public skiagm::GM { |
| 93 | sk_sp<SkShader> fBefore, fAfter, fThreshold; |
| 94 | sk_sp<SkRuntimeEffect> fEffect; |
| 95 | |
| 96 | float fCutoff = 0.5; // so we get something interested when we're not animated |
| 97 | |
| 98 | void onOnceBeforeDraw() override { |
| 99 | const SkISize size = {256, 256}; |
| 100 | fThreshold = make_threshold(size); |
| 101 | fBefore = make_shader(GetResourceAsImage("images/mandrill_256.png"), size); |
| 102 | fAfter = make_shader(GetResourceAsImage("images/dog.jpg"), size); |
| 103 | |
| 104 | const char code[] = R"( |
Brian Osman | 28590d5 | 2020-03-23 16:59:08 -0400 | [diff] [blame] | 105 | in shader before_map; |
| 106 | in shader after_map; |
| 107 | in shader threshold_map; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 108 | |
| 109 | uniform float cutoff; |
| 110 | uniform float slope; |
| 111 | |
| 112 | float smooth_cutoff(float x) { |
| 113 | x = x * slope + (0.5 - slope * cutoff); |
| 114 | return clamp(x, 0, 1); |
| 115 | } |
| 116 | |
| 117 | void main(float2 xy, inout half4 color) { |
Ethan Nicholas | fb5ede5 | 2020-06-10 09:23:19 -0400 | [diff] [blame] | 118 | half4 after = sample(after_map, float3x3(1)); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 119 | half4 before = sample(before_map, xy); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 120 | |
| 121 | float m = smooth_cutoff(sample(threshold_map, xy).r); |
| 122 | color = mix(before, after, half(m)); |
| 123 | } |
| 124 | )"; |
| 125 | auto [effect, error] = SkRuntimeEffect::Make(SkString(code)); |
| 126 | if (!effect) { |
| 127 | SkDebugf("runtime error %s\n", error.c_str()); |
| 128 | } |
| 129 | fEffect = effect; |
| 130 | } |
| 131 | |
| 132 | bool runAsBench() const override { return true; } |
| 133 | |
| 134 | SkString onShortName() override { return SkString("threshold_rt"); } |
| 135 | |
| 136 | SkISize onISize() override { return {256, 256}; } |
| 137 | |
| 138 | DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override { |
| 139 | if (canvas->getGrContext() == nullptr) { |
| 140 | // until SkSL can handle child processors on the raster backend |
| 141 | return DrawResult::kSkip; |
| 142 | } |
| 143 | |
| 144 | struct { |
| 145 | float cutoff, slope; |
| 146 | } uni = { |
| 147 | fCutoff, 10 |
| 148 | }; |
| 149 | sk_sp<SkData> data = SkData::MakeWithCopy(&uni, sizeof(uni)); |
| 150 | sk_sp<SkShader> children[] = { fBefore, fAfter, fThreshold }; |
| 151 | |
| 152 | SkPaint paint; |
| 153 | paint.setShader(fEffect->makeShader(data, children, SK_ARRAY_COUNT(children), |
| 154 | nullptr, true)); |
| 155 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 156 | |
| 157 | auto draw = [&](SkScalar x, SkScalar y, sk_sp<SkShader> shader) { |
| 158 | paint.setShader(shader); |
| 159 | canvas->save(); |
| 160 | canvas->translate(x, y); |
| 161 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 162 | canvas->restore(); |
| 163 | }; |
| 164 | draw(256, 0, fThreshold); |
| 165 | draw( 0, 256, fBefore); |
| 166 | draw(256, 256, fAfter); |
| 167 | |
| 168 | return DrawResult::kOk; |
| 169 | } |
| 170 | |
| 171 | bool onAnimate(double nanos) override { |
| 172 | double t = sin(nanos / (1000 * 1000 * 1000)); |
| 173 | fCutoff = float(t + 1) * 0.55f - 0.05f; |
| 174 | return true; |
| 175 | } |
| 176 | }; |
| 177 | DEF_GM(return new ThresholdRT;) |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 178 | |
| 179 | class SpiralRT : public skiagm::GM { |
| 180 | sk_sp<SkRuntimeEffect> fEffect; |
| 181 | float fSecs = 4; // so we get something interested when we're not animated |
| 182 | |
| 183 | void onOnceBeforeDraw() override { |
| 184 | const char code[] = R"( |
| 185 | uniform float rad_scale; |
| 186 | uniform float2 in_center; |
Brian Osman | b32d66b | 2020-04-30 17:12:03 -0400 | [diff] [blame] | 187 | layout(srgb_unpremul) uniform float4 in_colors0; |
| 188 | layout(srgb_unpremul) uniform float4 in_colors1; |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 189 | |
| 190 | void main(float2 p, inout half4 color) { |
| 191 | float2 pp = p - in_center; |
Mike Klein | 45be077 | 2020-05-01 09:13:18 -0500 | [diff] [blame] | 192 | float radius = length(pp); |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 193 | radius = sqrt(radius); |
| 194 | float angle = atan(pp.y / pp.x); |
| 195 | float t = (angle + 3.1415926/2) / (3.1415926); |
| 196 | t += radius * rad_scale; |
| 197 | t = fract(t); |
| 198 | float4 m = in_colors0 * (1-t) + in_colors1 * t; |
| 199 | color = half4(m); |
| 200 | } |
| 201 | )"; |
| 202 | auto [effect, error] = SkRuntimeEffect::Make(SkString(code)); |
| 203 | if (!effect) { |
| 204 | SkDebugf("runtime error %s\n", error.c_str()); |
| 205 | } |
| 206 | fEffect = effect; |
| 207 | } |
| 208 | |
| 209 | bool runAsBench() const override { return true; } |
| 210 | |
| 211 | SkString onShortName() override { return SkString("spiral_rt"); } |
| 212 | |
| 213 | SkISize onISize() override { return {512, 512}; } |
| 214 | |
| 215 | void onDraw(SkCanvas* canvas) override { |
| 216 | struct { |
| 217 | float rad_scale; |
| 218 | SkV2 in_center; |
| 219 | SkV4 in_colors0; |
| 220 | SkV4 in_colors1; |
| 221 | } uni { |
| 222 | std::sin(fSecs / 2) / 5, |
| 223 | {256, 256}, // center |
| 224 | {1, 0, 0, 1}, // color0 |
| 225 | {0, 1, 0, 1}, // color1 |
| 226 | }; |
| 227 | |
| 228 | SkPaint paint; |
| 229 | paint.setShader(fEffect->makeShader(SkData::MakeWithCopy(&uni, sizeof(uni)), |
| 230 | nullptr, 0, nullptr, true)); |
| 231 | canvas->drawRect({0, 0, 512, 512}, paint); |
| 232 | } |
| 233 | |
| 234 | bool onAnimate(double nanos) override { |
| 235 | fSecs = nanos / (1000 * 1000 * 1000); |
| 236 | return true; |
| 237 | } |
| 238 | }; |
| 239 | DEF_GM(return new SpiralRT;) |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 240 | |
| 241 | class ColorCubeRT : public skiagm::GM { |
| 242 | sk_sp<SkImage> fMandrill, fMandrillSepia, fIdentityCube, fSepiaCube; |
| 243 | sk_sp<SkRuntimeEffect> fEffect; |
| 244 | |
| 245 | void onOnceBeforeDraw() override { |
| 246 | fMandrill = GetResourceAsImage("images/mandrill_256.png"); |
| 247 | fMandrillSepia = GetResourceAsImage("images/mandrill_sepia.png"); |
| 248 | fIdentityCube = GetResourceAsImage("images/lut_identity.png"); |
| 249 | fSepiaCube = GetResourceAsImage("images/lut_sepia.png"); |
| 250 | |
| 251 | const char code[] = R"( |
| 252 | in shader input; |
| 253 | in shader color_cube; |
| 254 | |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 255 | uniform float rg_scale; |
| 256 | uniform float rg_bias; |
| 257 | uniform float b_scale; |
| 258 | uniform float inv_size; |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 259 | |
| 260 | void main(float2 xy, inout half4 color) { |
| 261 | float4 c = float4(unpremul(sample(input, xy))); |
| 262 | |
| 263 | // Map to cube coords: |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 264 | float3 cubeCoords = float3(c.rg * rg_scale + rg_bias, c.b * b_scale); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 265 | |
| 266 | // Compute slice coordinate |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 267 | float2 coords1 = float2((floor(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g); |
| 268 | float2 coords2 = float2(( ceil(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 269 | |
| 270 | // Two bilinear fetches, plus a manual lerp for the third axis: |
| 271 | color = mix(sample(color_cube, coords1), sample(color_cube, coords2), |
| 272 | half(fract(cubeCoords.b))); |
| 273 | |
| 274 | // Premul again |
| 275 | color.rgb *= color.a; |
| 276 | } |
| 277 | )"; |
| 278 | auto [effect, error] = SkRuntimeEffect::Make(SkString(code)); |
| 279 | if (!effect) { |
| 280 | SkDebugf("runtime error %s\n", error.c_str()); |
| 281 | } |
| 282 | fEffect = effect; |
| 283 | } |
| 284 | |
| 285 | SkString onShortName() override { return SkString("color_cube_rt"); } |
| 286 | |
Brian Osman | 921cdbb | 2020-05-29 08:11:20 -0400 | [diff] [blame] | 287 | SkISize onISize() override { return {512, 512}; } |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 288 | |
| 289 | DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override { |
| 290 | if (canvas->getGrContext() == nullptr) { |
| 291 | // until SkSL can handle child processors on the raster backend |
| 292 | return DrawResult::kSkip; |
| 293 | } |
| 294 | |
| 295 | // First we draw the unmodified image, and a copy that was sepia-toned in Photoshop: |
| 296 | canvas->drawImage(fMandrill, 0, 0); |
| 297 | canvas->drawImage(fMandrillSepia, 0, 256); |
| 298 | |
| 299 | // LUT dimensions should be (kSize^2, kSize) |
| 300 | constexpr float kSize = 16.0f; |
| 301 | |
| 302 | SkRuntimeShaderBuilder builder(fEffect); |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 303 | builder.input("rg_scale") = (kSize - 1) / kSize; |
| 304 | builder.input("rg_bias") = 0.5f / kSize; |
| 305 | builder.input("b_scale") = kSize - 1; |
| 306 | builder.input("inv_size") = 1.0f / kSize; |
| 307 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 308 | builder.child("input") = fMandrill->makeShader(); |
| 309 | |
| 310 | // TODO: Move filter quality to the shader itself. We need to enforce at least kLow here |
| 311 | // so that we bilerp the color cube image. |
| 312 | SkPaint paint; |
| 313 | paint.setFilterQuality(kLow_SkFilterQuality); |
| 314 | |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 315 | // TODO: Should we add SkImage::makeNormalizedShader() to handle this automatically? |
| 316 | SkMatrix normalize = SkMatrix::Scale(1.0f / (kSize * kSize), 1.0f / kSize); |
| 317 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 318 | // Now draw the image with an identity color cube - it should look like the original |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 319 | builder.child("color_cube") = fIdentityCube->makeShader(normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 320 | paint.setShader(builder.makeShader(nullptr, true)); |
| 321 | canvas->translate(256, 0); |
| 322 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 323 | |
| 324 | // ... and with a sepia-tone color cube. This should match the sepia-toned image. |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 325 | builder.child("color_cube") = fSepiaCube->makeShader(normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 326 | paint.setShader(builder.makeShader(nullptr, true)); |
| 327 | canvas->translate(0, 256); |
| 328 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 329 | |
| 330 | return DrawResult::kOk; |
| 331 | } |
| 332 | }; |
| 333 | DEF_GM(return new ColorCubeRT;) |