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" |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 14 | #include "include/core/SkSurface.h" |
| 15 | #include "include/effects/SkGradientShader.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 16 | #include "include/effects/SkImageFilters.h" |
Brian Osman | ee426f2 | 2020-01-02 11:55:24 -0500 | [diff] [blame] | 17 | #include "include/effects/SkRuntimeEffect.h" |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 18 | #include "include/utils/SkRandom.h" |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 19 | #include "tools/Resources.h" |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 20 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 21 | enum RT_Flags { |
| 22 | kAnimate_RTFlag = 0x1, |
| 23 | kBench_RTFlag = 0x2, |
| 24 | }; |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 25 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 26 | class RuntimeShaderGM : public skiagm::GM { |
| 27 | public: |
| 28 | RuntimeShaderGM(const char* name, SkISize size, const char* sksl, uint32_t flags = 0) |
| 29 | : fName(name), fSize(size), fFlags(flags), fSkSL(sksl) {} |
| 30 | |
| 31 | void onOnceBeforeDraw() override { |
| 32 | auto [effect, error] = SkRuntimeEffect::Make(fSkSL); |
| 33 | if (!effect) { |
| 34 | SkDebugf("RuntimeShader error: %s\n", error.c_str()); |
| 35 | } |
| 36 | fEffect = std::move(effect); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 37 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 38 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 39 | bool runAsBench() const override { return SkToBool(fFlags & kBench_RTFlag); } |
| 40 | SkString onShortName() override { return fName; } |
| 41 | SkISize onISize() override { return fSize; } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 42 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 43 | bool onAnimate(double nanos) override { |
| 44 | fSecs = nanos / (1000 * 1000 * 1000); |
| 45 | return SkToBool(fFlags & kAnimate_RTFlag); |
| 46 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 47 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 48 | protected: |
| 49 | SkString fName; |
| 50 | SkISize fSize; |
| 51 | uint32_t fFlags; |
| 52 | float fSecs = 0.0f; |
| 53 | |
| 54 | SkString fSkSL; |
| 55 | sk_sp<SkRuntimeEffect> fEffect; |
| 56 | }; |
| 57 | |
| 58 | class SimpleRT : public RuntimeShaderGM { |
| 59 | public: |
| 60 | SimpleRT() : RuntimeShaderGM("runtime_shader", {512, 256}, R"( |
| 61 | uniform half4 gColor; |
| 62 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 63 | half4 main(float2 p) { |
| 64 | return half4(half2(p)*(1.0/255), gColor.b, 1); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 65 | } |
| 66 | )", kBench_RTFlag) {} |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 67 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 68 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 69 | SkRuntimeShaderBuilder builder(fEffect); |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 70 | |
| 71 | SkMatrix localM; |
| 72 | localM.setRotate(90, 128, 128); |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 73 | builder.uniform("gColor") = SkColor4f{1, 0, 0, 1}; |
Brian Osman | 93de162 | 2019-12-26 08:43:05 -0500 | [diff] [blame] | 74 | |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 75 | SkPaint p; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 76 | p.setShader(builder.makeShader(&localM, true)); |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 77 | canvas->drawRect({0, 0, 256, 256}, p); |
| 78 | } |
Mike Reed | 3fd3cc9 | 2019-06-20 12:40:30 -0400 | [diff] [blame] | 79 | }; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 80 | DEF_GM(return new SimpleRT;) |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 81 | |
| 82 | static sk_sp<SkShader> make_shader(sk_sp<SkImage> img, SkISize size) { |
Mike Reed | 1f60733 | 2020-05-21 12:11:27 -0400 | [diff] [blame] | 83 | SkMatrix scale = SkMatrix::Scale(size.width() / (float)img->width(), |
| 84 | size.height() / (float)img->height()); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 85 | return img->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, &scale); |
| 86 | } |
| 87 | |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 88 | static sk_sp<SkShader> make_threshold(SkISize size) { |
| 89 | auto info = SkImageInfo::Make(size.width(), size.height(), kAlpha_8_SkColorType, |
| 90 | kPremul_SkAlphaType); |
| 91 | auto surf = SkSurface::MakeRaster(info); |
| 92 | auto canvas = surf->getCanvas(); |
| 93 | |
| 94 | const SkScalar rad = 50; |
| 95 | SkColor colors[] = {SK_ColorBLACK, 0}; |
| 96 | SkPaint paint; |
| 97 | paint.setAntiAlias(true); |
| 98 | paint.setShader(SkGradientShader::MakeRadial({0,0}, rad, colors, nullptr, 2, SkTileMode::kClamp)); |
| 99 | |
| 100 | SkPaint layerPaint; |
| 101 | const SkScalar sigma = 16.0f; |
| 102 | layerPaint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr)); |
| 103 | canvas->saveLayer(nullptr, &layerPaint); |
| 104 | |
| 105 | SkRandom rand; |
| 106 | for (int i = 0; i < 25; ++i) { |
| 107 | SkScalar x = rand.nextF() * size.width(); |
| 108 | SkScalar y = rand.nextF() * size.height(); |
| 109 | canvas->save(); |
| 110 | canvas->translate(x, y); |
| 111 | canvas->drawCircle(0, 0, rad, paint); |
| 112 | canvas->restore(); |
| 113 | } |
| 114 | |
| 115 | canvas->restore(); // apply the blur |
| 116 | |
| 117 | return surf->makeImageSnapshot()->makeShader(); |
| 118 | } |
| 119 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 120 | class ThresholdRT : public RuntimeShaderGM { |
| 121 | public: |
| 122 | ThresholdRT() : RuntimeShaderGM("threshold_rt", {256, 256}, R"( |
| 123 | in shader before_map; |
| 124 | in shader after_map; |
| 125 | in shader threshold_map; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 126 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 127 | uniform float cutoff; |
| 128 | uniform float slope; |
| 129 | |
| 130 | float smooth_cutoff(float x) { |
| 131 | x = x * slope + (0.5 - slope * cutoff); |
| 132 | return clamp(x, 0, 1); |
| 133 | } |
| 134 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 135 | half4 main(float2 xy) { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 136 | half4 before = sample(before_map); |
| 137 | half4 after = sample(after_map); |
| 138 | |
| 139 | float m = smooth_cutoff(sample(threshold_map).a); |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 140 | return mix(before, after, half(m)); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 141 | } |
| 142 | )", kAnimate_RTFlag | kBench_RTFlag) {} |
| 143 | |
| 144 | sk_sp<SkShader> fBefore, fAfter, fThreshold; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 145 | |
| 146 | void onOnceBeforeDraw() override { |
| 147 | const SkISize size = {256, 256}; |
| 148 | fThreshold = make_threshold(size); |
| 149 | fBefore = make_shader(GetResourceAsImage("images/mandrill_256.png"), size); |
| 150 | fAfter = make_shader(GetResourceAsImage("images/dog.jpg"), size); |
| 151 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 152 | this->RuntimeShaderGM::onOnceBeforeDraw(); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 153 | } |
| 154 | |
Mike Klein | f8d68fe | 2020-06-18 10:01:31 -0500 | [diff] [blame] | 155 | void onDraw(SkCanvas* canvas) override { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 156 | SkRuntimeShaderBuilder builder(fEffect); |
| 157 | |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 158 | builder.uniform("cutoff") = sin(fSecs) * 0.55f + 0.5f; |
| 159 | builder.uniform("slope") = 10.0f; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 160 | |
| 161 | builder.child("before_map") = fBefore; |
| 162 | builder.child("after_map") = fAfter; |
| 163 | builder.child("threshold_map") = fThreshold; |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 164 | |
| 165 | SkPaint paint; |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 166 | paint.setShader(builder.makeShader(nullptr, true)); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 167 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 168 | |
| 169 | auto draw = [&](SkScalar x, SkScalar y, sk_sp<SkShader> shader) { |
| 170 | paint.setShader(shader); |
| 171 | canvas->save(); |
| 172 | canvas->translate(x, y); |
| 173 | canvas->drawRect({0, 0, 256, 256}, paint); |
| 174 | canvas->restore(); |
| 175 | }; |
| 176 | draw(256, 0, fThreshold); |
| 177 | draw( 0, 256, fBefore); |
| 178 | draw(256, 256, fAfter); |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 179 | } |
Mike Reed | 146722e | 2020-02-13 12:36:28 -0500 | [diff] [blame] | 180 | }; |
| 181 | DEF_GM(return new ThresholdRT;) |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 182 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 183 | class SpiralRT : public RuntimeShaderGM { |
| 184 | public: |
| 185 | SpiralRT() : RuntimeShaderGM("spiral_rt", {512, 512}, R"( |
| 186 | uniform float rad_scale; |
| 187 | uniform float2 in_center; |
| 188 | layout(srgb_unpremul) uniform float4 in_colors0; |
| 189 | layout(srgb_unpremul) uniform float4 in_colors1; |
Mike Reed | 8520e76 | 2020-04-30 12:06:23 -0400 | [diff] [blame] | 190 | |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 191 | half4 main(float2 p) { |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 192 | float2 pp = p - in_center; |
| 193 | float radius = length(pp); |
| 194 | radius = sqrt(radius); |
| 195 | float angle = atan(pp.y / pp.x); |
| 196 | float t = (angle + 3.1415926/2) / (3.1415926); |
| 197 | t += radius * rad_scale; |
| 198 | t = fract(t); |
| 199 | float4 m = in_colors0 * (1-t) + in_colors1 * t; |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 200 | return half4(m); |
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"( |
| 222 | in shader input; |
| 223 | in shader color_cube; |
| 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 | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 231 | float4 c = float4(unpremul(sample(input))); |
| 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), |
| 242 | half(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 | |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 272 | builder.uniform("rg_scale") = (kSize - 1) / kSize; |
| 273 | builder.uniform("rg_bias") = 0.5f / kSize; |
| 274 | builder.uniform("b_scale") = kSize - 1; |
| 275 | builder.uniform("inv_size") = 1.0f / kSize; |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 276 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 277 | builder.child("input") = fMandrill->makeShader(); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 278 | |
| 279 | // TODO: Move filter quality to the shader itself. We need to enforce at least kLow here |
| 280 | // so that we bilerp the color cube image. |
| 281 | SkPaint paint; |
| 282 | paint.setFilterQuality(kLow_SkFilterQuality); |
| 283 | |
Brian Osman | 2c28bf9 | 2020-05-28 13:38:24 -0400 | [diff] [blame] | 284 | // TODO: Should we add SkImage::makeNormalizedShader() to handle this automatically? |
| 285 | SkMatrix normalize = SkMatrix::Scale(1.0f / (kSize * kSize), 1.0f / kSize); |
| 286 | |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 287 | // 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] | 288 | builder.child("color_cube") = fIdentityCube->makeShader(normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 289 | paint.setShader(builder.makeShader(nullptr, true)); |
| 290 | canvas->translate(256, 0); |
| 291 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 292 | |
| 293 | // ... 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] | 294 | builder.child("color_cube") = fSepiaCube->makeShader(normalize); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 295 | paint.setShader(builder.makeShader(nullptr, true)); |
| 296 | canvas->translate(0, 256); |
| 297 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
Brian Osman | 9c3eccd | 2020-05-21 16:41:43 -0400 | [diff] [blame] | 298 | } |
| 299 | }; |
| 300 | DEF_GM(return new ColorCubeRT;) |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 301 | |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 302 | class DefaultColorRT : public RuntimeShaderGM { |
| 303 | public: |
Brian Osman | 5240e18 | 2020-08-12 10:22:34 -0400 | [diff] [blame] | 304 | // This test also *explicitly* doesn't include coords in main's parameter list, to test that |
| 305 | // runtime shaders work without them being declared (when they're not used). |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 306 | DefaultColorRT() : RuntimeShaderGM("default_color_rt", {512, 256}, R"( |
| 307 | in shader input; |
Brian Osman | 767f444 | 2020-08-13 16:59:48 -0400 | [diff] [blame^] | 308 | half4 main() { |
| 309 | return sample(input); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 310 | } |
| 311 | )") {} |
| 312 | |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 313 | sk_sp<SkImage> fMandrill; |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 314 | |
| 315 | void onOnceBeforeDraw() override { |
| 316 | fMandrill = GetResourceAsImage("images/mandrill_256.png"); |
Brian Osman | 44fafa6 | 2020-07-15 10:52:37 -0400 | [diff] [blame] | 317 | this->RuntimeShaderGM::onOnceBeforeDraw(); |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 318 | } |
| 319 | |
Brian Osman | a7685b2 | 2020-07-10 14:08:56 -0400 | [diff] [blame] | 320 | void onDraw(SkCanvas* canvas) override { |
| 321 | SkRuntimeShaderBuilder builder(fEffect); |
| 322 | |
| 323 | // First, we leave the child as null, so sampling it returns the default (paint) color |
| 324 | SkPaint paint; |
| 325 | paint.setColor4f({ 0.25f, 0.75f, 0.75f, 1.0f }); |
| 326 | paint.setShader(builder.makeShader(nullptr, false)); |
| 327 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 328 | |
| 329 | // Now we bind an image shader as the child. This (by convention) scales by the paint alpha |
| 330 | builder.child("input") = fMandrill->makeShader(); |
| 331 | paint.setColor4f({ 1.0f, 1.0f, 1.0f, 0.5f }); |
| 332 | paint.setShader(builder.makeShader(nullptr, false)); |
| 333 | canvas->translate(256, 0); |
| 334 | canvas->drawRect({ 0, 0, 256, 256 }, paint); |
| 335 | |
| 336 | } |
| 337 | }; |
| 338 | DEF_GM(return new DefaultColorRT;) |