| /* |
| * 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 |
