SkKnownRuntimeEffects.cpp

Go to the documentation of this file.

/*
 * Copyright 2024 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#include "src/core/SkKnownRuntimeEffects.h"
 
#include "include/core/SkString.h"
#include "include/effects/SkRuntimeEffect.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/effects/imagefilters/SkMatrixConvolutionImageFilter.h"
 
namespace SkKnownRuntimeEffects {
 
namespace {
 
// This must be kept in sync w/ the version in BlurUtils.h
static constexpr int kMaxBlurSamples = 28;
 
SkRuntimeEffect* make_blur_1D_effect(int kernelWidth, const SkRuntimeEffect::Options& options) {
    SkASSERT(kernelWidth <= kMaxBlurSamples);
    // The SkSL structure performs two kernel taps; if the kernel has an odd width the last
    // sample will be skipped with the current loop limit calculation.
    SkASSERT(kernelWidth % 2 == 0);
    return SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
            SkStringPrintf(
                    // The coefficients are always stored for the max radius to keep the
                    // uniform block consistent across all effects.
                    "const int kMaxUniformKernelSize = %d / 2;"
                    // But we generate an exact loop over the kernel size. Note that this
                    // program can be used for kernels smaller than the constructed max as long
                    // as the kernel weights for excess entries are set to 0.
                    "const int kMaxLoopLimit = %d / 2;"
 
                    "uniform half4 offsetsAndKernel[kMaxUniformKernelSize];"
                    "uniform half2 dir;"
 
                    "uniform shader child;"
 
                    "half4 main(float2 coord) {"
                        "half4 sum = half4(0);"
                        "for (int i = 0; i < kMaxLoopLimit; ++i) {"
                            "half4 s = offsetsAndKernel[i];"
                            "sum += s.y * child.eval(coord + s.x*dir);"
                            "sum += s.w * child.eval(coord + s.z*dir);"
                        "}"
                        "return sum;"
                    "}", kMaxBlurSamples, kernelWidth).c_str(),
                    options);
}
 
SkRuntimeEffect* make_blur_2D_effect(int maxKernelSize, const SkRuntimeEffect::Options& options) {
    SkASSERT(maxKernelSize % 4 == 0);
    return SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
            SkStringPrintf(
                    // The coefficients are always stored for the max radius to keep the
                    // uniform block consistent across all effects.
                    "const int kMaxUniformKernelSize = %d / 4;"
                    "const int kMaxUniformOffsetsSize = 2*kMaxUniformKernelSize;"
                    // But we generate an exact loop over the kernel size. Note that this
                    // program can be used for kernels smaller than the constructed max as long
                    // as the kernel weights for excess entries are set to 0.
                    "const int kMaxLoopLimit = %d / 4;"
 
                    // Pack scalar coefficients into half4 for better packing on std140, and
                    // upload offsets to avoid having to transform the 1D index into a 2D coord
                    "uniform half4 kernel[kMaxUniformKernelSize];"
                    "uniform half4 offsets[kMaxUniformOffsetsSize];"
 
                    "uniform shader child;"
 
                    "half4 main(float2 coord) {"
                        "half4 sum = half4(0);"
 
                        "for (int i = 0; i < kMaxLoopLimit; ++i) {"
                            "half4 k = kernel[i];"
                            "half4 o = offsets[2*i];"
                            "sum += k.x * child.eval(coord + o.xy);"
                            "sum += k.y * child.eval(coord + o.zw);"
                            "o = offsets[2*i + 1];"
                            "sum += k.z * child.eval(coord + o.xy);"
                            "sum += k.w * child.eval(coord + o.zw);"
                        "}"
                        "return sum;"
                    "}", kMaxBlurSamples, maxKernelSize).c_str(),
                    options);
}
 
enum class MatrixConvolutionImpl {
    kUniformBased,
    kTextureBasedSm,
    kTextureBasedLg,
};
 
// There are three shader variants:
//    a smaller kernel version that stores the matrix in uniforms and iterates in 1D
//    a larger kernel version that stores the matrix in a 1D texture. The texture version has small
//    and large variants w/ the actual kernel size uploaded as a uniform.
SkRuntimeEffect* make_matrix_conv_effect(MatrixConvolutionImpl impl,
                                         const SkRuntimeEffect::Options& options) {
    // While the uniforms and kernel access are different, pieces of the algorithm are common and
    // defined statically for re-use in the two shaders:
    static const char* kHeaderAndBeginLoopSkSL =
        "uniform int2 size;"
        "uniform int2 offset;"
        "uniform half2 gainAndBias;"
        "uniform int convolveAlpha;" // FIXME not a full  int? Put in a half3 w/ gainAndBias?
 
        "uniform shader child;"
 
        "half4 main(float2 coord) {"
            "half4 sum = half4(0);"
            "half origAlpha = 0;"
            "int2 kernelPos = int2(0);"
            "for (int i = 0; i < kMaxKernelSize; ++i) {"
                "if (kernelPos.y >= size.y) { break; }";
 
    // Used in the inner loop to accumulate convolution sum and increment the kernel position
    static const char* kAccumulateAndIncrementSkSL =
                "half4 c = child.eval(coord + half2(kernelPos) - half2(offset));"
                "if (convolveAlpha == 0) {"
                    // When not convolving alpha, remember the original alpha for actual sample
                    // coord, and perform accumulation on unpremul colors.
                    "if (kernelPos == offset) {"
                        "origAlpha = c.a;"
                    "}"
                    "c = unpremul(c);"
                "}"
                "sum += c*k;"
                "kernelPos.x += 1;"
                "if (kernelPos.x >= size.x) {"
                    "kernelPos.x = 0;"
                    "kernelPos.y += 1;"
                "}";
 
    // Closes the loop and calculates final color
    static const char* kCloseLoopAndFooterSkSL =
            "}"
            "half4 color = sum*gainAndBias.x + gainAndBias.y;"
            "if (convolveAlpha == 0) {"
                // Reset the alpha to the original and convert to premul RGB
                "color = half4(color.rgb*origAlpha, origAlpha);"
            "} else {"
                // Ensure convolved alpha is within [0, 1]
                "color.a = saturate(color.a);"
            "}"
            // Make RGB valid premul w/ respect to the alpha (either original or convolved)
            "color.rgb = clamp(color.rgb, 0, color.a);"
            "return color;"
        "}";
 
    static const auto makeTextureEffect = [](int maxTextureKernelSize,
                                             const SkRuntimeEffect::Options& options) {
        return SkMakeRuntimeEffect(
                        SkRuntimeEffect::MakeForShader,
                        SkStringPrintf("const int kMaxKernelSize = %d;"
                                       "uniform shader kernel;"
                                       "uniform half2 innerGainAndBias;"
                                       "%s" // kHeaderAndBeginLoopSkSL
                                               "half k = kernel.eval(half2(half(i) + 0.5, 0.5)).a;"
                                               "k = k * innerGainAndBias.x + innerGainAndBias.y;"
                                               "%s" // kAccumulateAndIncrementSkSL
                                       "%s", // kCloseLoopAndFooterSkSL
                                       maxTextureKernelSize,
                                       kHeaderAndBeginLoopSkSL,
                                       kAccumulateAndIncrementSkSL,
                                       kCloseLoopAndFooterSkSL).c_str(),
                        options);
    };
 
    switch (impl) {
        case MatrixConvolutionImpl::kUniformBased: {
            return SkMakeRuntimeEffect(
                        SkRuntimeEffect::MakeForShader,
                        SkStringPrintf("const int kMaxKernelSize = %d / 4;"
                                       "uniform half4 kernel[kMaxKernelSize];"
                                       "%s" // kHeaderAndBeginLoopSkSL
                                                "half4 k4 = kernel[i];"
                                                "for (int j = 0; j < 4; ++j) {"
                                                    "if (kernelPos.y >= size.y) { break; }"
                                                    "half k = k4[j];"
                                                    "%s" // kAccumulateAndIncrementSkSL
                                                "}"
                                       "%s", // kCloseLoopAndFooterSkSL
                                       MatrixConvolutionImageFilter::kMaxUniformKernelSize,
                                       kHeaderAndBeginLoopSkSL,
                                       kAccumulateAndIncrementSkSL,
                                       kCloseLoopAndFooterSkSL).c_str(),
                        options);
        }
        case MatrixConvolutionImpl::kTextureBasedSm:
            return makeTextureEffect(MatrixConvolutionImageFilter::kSmallKernelSize, options);
        case MatrixConvolutionImpl::kTextureBasedLg:
            return makeTextureEffect(MatrixConvolutionImageFilter::kLargeKernelSize, options);
    }
 
    SkUNREACHABLE;
}
 
} // anonymous namespace
 
const SkRuntimeEffect* GetKnownRuntimeEffect(StableKey stableKey) {
    SkRuntimeEffect::Options options;
    SkRuntimeEffectPriv::SetStableKey(&options, static_cast<uint32_t>(stableKey));
 
    switch (stableKey) {
        case StableKey::kInvalid:
            return nullptr;
 
        // Shaders
        case StableKey::k1DBlur4: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(4, options);
            return s1DBlurEffect;
        }
        case StableKey::k1DBlur8: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(8, options);
            return s1DBlurEffect;
        }
        case StableKey::k1DBlur12: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(12, options);
            return s1DBlurEffect;
        }
        case StableKey::k1DBlur16: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(16, options);
            return s1DBlurEffect;
        }
        case StableKey::k1DBlur20: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(20, options);
            return s1DBlurEffect;
        }
        case StableKey::k1DBlur28: {
            static SkRuntimeEffect* s1DBlurEffect = make_blur_1D_effect(28, options);
            return s1DBlurEffect;
        }
        case StableKey::k2DBlur4: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(4, options);
            return s2DBlurEffect;
        }
        case StableKey::k2DBlur8: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(8, options);
            return s2DBlurEffect;
        }
        case StableKey::k2DBlur12: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(12, options);
            return s2DBlurEffect;
        }
        case StableKey::k2DBlur16: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(16, options);
            return s2DBlurEffect;
        }
        case StableKey::k2DBlur20: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(20, options);
            return s2DBlurEffect;
        }
        case StableKey::k2DBlur28: {
            static SkRuntimeEffect* s2DBlurEffect = make_blur_2D_effect(28, options);
            return s2DBlurEffect;
        }
        case StableKey::kBlend: {
            static constexpr char kBlendShaderCode[] =
                "uniform shader s, d;"
                "uniform blender b;"
                "half4 main(float2 xy) {"
                    "return b.eval(s.eval(xy), d.eval(xy));"
                "}";
 
            static const SkRuntimeEffect* sBlendEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kBlendShaderCode,
                                        options);
            return sBlendEffect;
        }
        case StableKey::kDecal: {
            static constexpr char kDecalShaderCode[] =
                "uniform shader image;"
                "uniform float4 decalBounds;"
 
                "half4 main(float2 coord) {"
                    "half4 d = half4(decalBounds - coord.xyxy) * half4(-1, -1, 1, 1);"
                    "d = saturate(d + 0.5);"
                    "return (d.x*d.y*d.z*d.w) * image.eval(coord);"
                "}";
 
            static const SkRuntimeEffect* sDecalEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kDecalShaderCode,
                                        options);
            return sDecalEffect;
        }
        case StableKey::kDisplacement: {
            // NOTE: This uses dot product selection to work on all GLES2 hardware (enforced by
            // public runtime effect restrictions). Otherwise, this would use a "uniform ivec2"
            // and component indexing to convert the displacement color into a vector.
            static constexpr char kDisplacementShaderCode[] =
                "uniform shader displMap;"
                "uniform shader colorMap;"
                "uniform half2 scale;"
                "uniform half4 xSelect;" // Only one of RGBA will be 1, the rest are 0
                "uniform half4 ySelect;"
 
                "half4 main(float2 coord) {"
                    "half4 displColor = unpremul(displMap.eval(coord));"
                    "half2 displ = half2(dot(displColor, xSelect), dot(displColor, ySelect));"
                    "displ = scale * (displ - 0.5);"
                    "return colorMap.eval(coord + displ);"
                "}";
 
            static const SkRuntimeEffect* sDisplacementEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kDisplacementShaderCode,
                                        options);
            return sDisplacementEffect;
        }
        case StableKey::kLighting: {
            static constexpr char kLightingShaderCode[] =
                "const half kConeAAThreshold = 0.016;"
                "const half kConeScale = 1.0 / kConeAAThreshold;"
 
                "uniform shader normalMap;"
 
                // Packs surface depth, shininess, material type (0 == diffuse) and light type
                // (< 0 = distant, 0 = point, > 0 = spot)
                "uniform half4 materialAndLightType;"
 
                "uniform half4 lightPosAndSpotFalloff;" // (x,y,z) are lightPos, w is spot falloff
                                                        // exponent
                "uniform half4 lightDirAndSpotCutoff;" // (x,y,z) are lightDir,
                                                       // w is spot cos(cutoffAngle)
                "uniform half3 lightColor;" // Material's k has already been multiplied in
 
                "half3 surface_to_light(half3 coord) {"
                    "if (materialAndLightType.w < 0) {"
                        "return lightDirAndSpotCutoff.xyz;"
                    "} else {"
                        // Spot and point have the same equation
                        "return normalize(lightPosAndSpotFalloff.xyz - coord);"
                    "}"
                "}"
 
                "half spotlight_scale(half3 surfaceToLight) {"
                    "half cosCutoffAngle = lightDirAndSpotCutoff.w;"
                    "half cosAngle = -dot(surfaceToLight, lightDirAndSpotCutoff.xyz);"
                    "if (cosAngle < cosCutoffAngle) {"
                        "return 0.0;"
                    "}"
                    "half scale = pow(cosAngle, lightPosAndSpotFalloff.w);"
                    "if (cosAngle < cosCutoffAngle + kConeAAThreshold) {"
                        "return scale * (cosAngle - cosCutoffAngle) * kConeScale;"
                    "} else {"
                        "return scale;"
                    "}"
                "}"
 
                "half4 compute_lighting(half3 normal, half3 surfaceToLight) {"
                    // Point and distant light color contributions are constant
                    "half3 color = lightColor;"
                    // Spotlights fade based on the angle away from its direction
                    "if (materialAndLightType.w > 0) {"
                        "color *= spotlight_scale(surfaceToLight);"
                    "}"
 
                    // Diffuse and specular reflections scale the light's "color" differently
                    "if (materialAndLightType.z == 0) {"
                        "half coeff = dot(normal, surfaceToLight);"
                        "color = saturate(coeff * color);"
                        "return half4(color, 1.0);"
                    "} else {"
                        "half3 halfDir = normalize(surfaceToLight + half3(0, 0, 1));"
                        "half shininess = materialAndLightType.y;"
                        "half coeff = pow(dot(normal, halfDir), shininess);"
                        "color = saturate(coeff * color);"
                        "return half4(color, max(max(color.r, color.g), color.b));"
                    "}"
                "}"
 
                "half4 main(float2 coord) {"
                    "half4 normalAndA = normalMap.eval(coord);"
                    "half depth = materialAndLightType.x;"
                    "half3 surfaceToLight = surface_to_light(half3(half2(coord),"
                                                                  "depth*normalAndA.a));"
                    "return compute_lighting(normalAndA.xyz, surfaceToLight);"
                "}";
 
            static const SkRuntimeEffect* sLightingEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kLightingShaderCode,
                                        options);
            return sLightingEffect;
        }
        case StableKey::kLinearMorphology: {
            static constexpr char kLinearMorphologyShaderCode[] =
                // KEEP IN SYNC WITH SkMorphologyImageFilter.cpp DEFINITION
                "const int kMaxLinearRadius = 14;"
 
                "uniform shader child;"
                "uniform half2 offset;"
                "uniform half flip;" // -1 converts the max() calls to min()
                "uniform int radius;"
 
                "half4 main(float2 coord) {"
                    "half4 aggregate = flip*child.eval(coord);" // case 0 only samples once
                    "for (int i = 1; i <= kMaxLinearRadius; ++i) {"
                        "if (i > radius) break;"
                        "half2 delta = half(i) * offset;"
                        "aggregate = max(aggregate, max(flip*child.eval(coord + delta),"
                                                       "flip*child.eval(coord - delta)));"
                    "}"
                    "return flip*aggregate;"
                "}";
 
            static const SkRuntimeEffect* sLinearMorphologyEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kLinearMorphologyShaderCode,
                                        options);
            return sLinearMorphologyEffect;
        }
 
        case StableKey::kMagnifier: {
            static constexpr char kMagnifierShaderCode[] =
                "uniform shader src;"
                "uniform float4 lensBounds;"
                "uniform float4 zoomXform;"
                "uniform float2 invInset;"
 
                "half4 main(float2 coord) {"
                    "float2 zoomCoord = zoomXform.xy + zoomXform.zw*coord;"
                    // edgeInset is the smallest distance to the lens bounds edges,
                    // in units of "insets".
                    "float2 edgeInset = min(coord - lensBounds.xy, lensBounds.zw - coord) *"
                                       "invInset;"
 
                    // The equations for 'weight' ensure that it is 0 along the outside of
                    // lensBounds so it seams with any un-zoomed, un-filtered content. The zoomed
                    // content fills a rounded rectangle that is 1 "inset" in from lensBounds with
                    // circular corners with radii equal to the inset distance. Outside of this
                    // region, there is a non-linear weighting to compress the un-zoomed content
                    // to the zoomed content. The critical zone about each corner is limited
                    // to 2x"inset" square.
                    "float weight = (edgeInset.x < 2.0 && edgeInset.y < 2.0)"
                        // Circular distortion weighted by distance to inset corner
                        "? (2.0 - length(2.0 - edgeInset))"
                        // Linear zoom, or single-axis compression outside of the inset
                        // area (if delta < 1)
                        ": min(edgeInset.x, edgeInset.y);"
 
                    // Saturate before squaring so that negative weights are clamped to 0
                    // before squaring
                    "weight = saturate(weight);"
                    "return src.eval(mix(coord, zoomCoord, weight*weight));"
                "}";
 
            static const SkRuntimeEffect* sMagnifierEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kMagnifierShaderCode,
                                        options);
            return sMagnifierEffect;
        }
 
        case StableKey::kMatrixConvUniforms: {
            static const SkRuntimeEffect* sMatrixConvUniformsEffect =
                    make_matrix_conv_effect(MatrixConvolutionImpl::kUniformBased, options);
            return sMatrixConvUniformsEffect;
        }
 
        case StableKey::kMatrixConvTexSm: {
            static const SkRuntimeEffect* sMatrixConvTexSmEffect =
                    make_matrix_conv_effect(MatrixConvolutionImpl::kTextureBasedSm, options);
            return sMatrixConvTexSmEffect;
        }
 
        case StableKey::kMatrixConvTexLg: {
            static const SkRuntimeEffect* sMatrixConvTexMaxEffect =
                    make_matrix_conv_effect(MatrixConvolutionImpl::kTextureBasedLg, options);
            return sMatrixConvTexMaxEffect;
        }
 
        case StableKey::kNormal: {
            static constexpr char kNormalShaderCode[] =
                "uniform shader alphaMap;"
                "uniform float4 edgeBounds;"
                "uniform half negSurfaceDepth;"
 
                "half3 normal(half3 alphaC0, half3 alphaC1, half3 alphaC2) {"
                    // The right column (or bottom row) terms of the Sobel filter. The left/top is
                    // just the negative, and the middle row/column is all 0s so those instructions
                    // are skipped.
                    "const half3 kSobel = 0.25 * half3(1,2,1);"
                    "half3 alphaR0 = half3(alphaC0.x, alphaC1.x, alphaC2.x);"
                    "half3 alphaR2 = half3(alphaC0.z, alphaC1.z, alphaC2.z);"
                    "half nx = dot(kSobel, alphaC2) - dot(kSobel, alphaC0);"
                    "half ny = dot(kSobel, alphaR2) - dot(kSobel, alphaR0);"
                    "return normalize(half3(negSurfaceDepth * half2(nx, ny), 1));"
                "}"
 
                "half4 main(float2 coord) {"
                   "half3 alphaC0 = half3("
                     "alphaMap.eval(clamp(coord + float2(-1,-1), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2(-1, 0), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2(-1, 1), edgeBounds.LT, edgeBounds.RB)).a);"
                   "half3 alphaC1 = half3("
                     "alphaMap.eval(clamp(coord + float2( 0,-1), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2( 0, 0), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2( 0, 1), edgeBounds.LT, edgeBounds.RB)).a);"
                   "half3 alphaC2 = half3("
                     "alphaMap.eval(clamp(coord + float2( 1,-1), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2( 1, 0), edgeBounds.LT, edgeBounds.RB)).a,"
                     "alphaMap.eval(clamp(coord + float2( 1, 1), edgeBounds.LT, edgeBounds.RB)).a);"
 
                   "half mainAlpha = alphaC1.y;" // offset = (0,0)
                   "return half4(normal(alphaC0, alphaC1, alphaC2), mainAlpha);"
                "}";
 
            static const SkRuntimeEffect* sNormalEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kNormalShaderCode,
                                        options);
            return sNormalEffect;
        }
        case StableKey::kSparseMorphology: {
            static constexpr char kSparseMorphologyShaderCode[] =
                "uniform shader child;"
                "uniform half2 offset;"
                "uniform half flip;"
 
                "half4 main(float2 coord) {"
                    "half4 aggregate = max(flip*child.eval(coord + offset),"
                                          "flip*child.eval(coord - offset));"
                    "return flip*aggregate;"
                "}";
 
            static const SkRuntimeEffect* sSparseMorphologyEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
                                        kSparseMorphologyShaderCode,
                                        options);
            return sSparseMorphologyEffect;
        }
 
        // Blenders
        case StableKey::kArithmetic: {
            static constexpr char kArithmeticBlenderCode[] =
                "uniform half4 k;"
                "uniform half pmClamp;"
 
                "half4 main(half4 src, half4 dst) {"
                    "half4 c = saturate(k.x * src * dst + k.y * src + k.z * dst + k.w);"
                    "c.rgb = min(c.rgb, max(c.a, pmClamp));"
                    "return c;"
                "}";
 
            static const SkRuntimeEffect* sArithmeticEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForBlender,
                                        kArithmeticBlenderCode,
                                        options);
            return sArithmeticEffect;
        }
 
        // Color Filters
        case StableKey::kHighContrast: {
            static constexpr char kHighContrastFilterCode[] =
                "uniform half grayscale, invertStyle, contrast;"
 
                "half3 rgb_to_hsl(half3 c) {"
                    "half mx = max(max(c.r,c.g),c.b),"
                         "mn = min(min(c.r,c.g),c.b),"
                          "d = mx-mn,"
                       "invd = 1.0 / d,"
                     "g_lt_b = c.g < c.b ? 6.0 : 0.0;"
 
                // We'd prefer to write these tests like `mx == c.r`, but on some GPUs max(x,y) is
                // not always equal to either x or y. So we use long form, c.r >= c.g && c.r >= c.b.
                    "half h = (1/6.0) * (mx == mn"               "? 0.0 :"
                         /*mx==c.r*/    "c.r >= c.g && c.r >= c.b ? invd * (c.g - c.b) + g_lt_b :"
                         /*mx==c.g*/    "c.g >= c.b"             "? invd * (c.b - c.r) + 2.0"
                         /*mx==c.b*/                             ": invd * (c.r - c.g) + 4.0);"
                    "half sum = mx+mn,"
                           "l = sum * 0.5,"
                           "s = mx == mn ? 0.0"
                                        ": d / (l > 0.5 ? 2.0 - sum : sum);"
                    "return half3(h,s,l);"
                "}"
                "half4 main(half4 inColor) {"
                    "half3 c = inColor.rgb;"
                    "if (grayscale == 1) {"
                        "c = dot(half3(0.2126, 0.7152, 0.0722), c).rrr;"
                    "}"
                    "if (invertStyle == 1) {"  // brightness
                        "c = 1 - c;"
                    "} else if (invertStyle == 2) {"  // lightness
                        "c = rgb_to_hsl(c);"
                        "c.b = 1 - c.b;"
                        "c = $hsl_to_rgb(c);"
                    "}"
                    "c = mix(half3(0.5), c, contrast);"
                    "return half4(saturate(c), inColor.a);"
                "}";
 
            static const SkRuntimeEffect* sHighContrastEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
                                        kHighContrastFilterCode,
                                        options);
            return sHighContrastEffect;
        }
 
        case StableKey::kLerp: {
            static constexpr char kLerpFilterCode[] =
                "uniform colorFilter cf0;"
                "uniform colorFilter cf1;"
                "uniform half weight;"
 
                "half4 main(half4 color) {"
                    "return mix(cf0.eval(color), cf1.eval(color), weight);"
                "}";
 
            static const SkRuntimeEffect* sLerpEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
                                        kLerpFilterCode,
                                        options);
            return sLerpEffect;
        }
 
        case StableKey::kLuma: {
            static constexpr char kLumaFilterCode[] =
                "half4 main(half4 inColor) {"
                    "return saturate(dot(half3(0.2126, 0.7152, 0.0722), inColor.rgb)).000r;"
                "}";
 
            static const SkRuntimeEffect* sLumaEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
                                        kLumaFilterCode,
                                        options);
            return sLumaEffect;
        }
 
        case StableKey::kOverdraw: {
            static constexpr char kOverdrawFilterCode[] =
                "uniform half4 color0, color1, color2, color3, color4, color5;"
 
                "half4 main(half4 color) {"
                    "half alpha = 255.0 * color.a;"
                    "return alpha < 0.5 ? color0"
                         ": alpha < 1.5 ? color1"
                         ": alpha < 2.5 ? color2"
                         ": alpha < 3.5 ? color3"
                         ": alpha < 4.5 ? color4 : color5;"
                "}";
 
            static const SkRuntimeEffect* sOverdrawEffect =
                    SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
                                        kOverdrawFilterCode,
                                        options);
            return sOverdrawEffect;
        }
    }
 
    SkUNREACHABLE;
}
 
} // namespace SkKnownRuntimeEffects