| /* |
| * Copyright 2022 Rive |
| */ |
| |
| // From the KHR_blend_equation_advanced spec: |
| // |
| // The advanced blend equations are those listed in tables X.1 and X.2. When |
| // using one of these equations, blending is performed according to the |
| // following equations: |
| // |
| // R = f(Rs',Rd')*p0(As,Ad) + Y*Rs'*p1(As,Ad) + Z*Rd'*p2(As,Ad) |
| // G = f(Gs',Gd')*p0(As,Ad) + Y*Gs'*p1(As,Ad) + Z*Gd'*p2(As,Ad) |
| // B = f(Bs',Bd')*p0(As,Ad) + Y*Bs'*p1(As,Ad) + Z*Bd'*p2(As,Ad) |
| // A = X*p0(As,Ad) + Y*p1(As,Ad) + Z*p2(As,Ad) |
| // |
| // where the function f and terms X, Y, and Z are specified in the table. |
| // The R, G, and B components of the source color used for blending are |
| // considered to have been premultiplied by the A component prior to |
| // blending. The base source color (Rs',Gs',Bs') is obtained by dividing |
| // through by the A component: |
| // |
| // (Rs', Gs', Bs') = |
| // (0, 0, 0), if As == 0 |
| // (Rs/As, Gs/As, Bs/As), otherwise |
| // |
| // The destination color components are always considered to have been |
| // premultiplied by the destination A component and the base destination |
| // color (Rd', Gd', Bd') is obtained by dividing through by the A component: |
| // |
| // (Rd', Gd', Bd') = |
| // (0, 0, 0), if Ad == 0 |
| // (Rd/Ad, Gd/Ad, Bd/Ad), otherwise |
| // |
| // When blending using advanced blend equations, we expect that the R, G, and |
| // B components of premultiplied source and destination color inputs be |
| // stored as the product of non-premultiplied R, G, and B components and the |
| // A component of the color. If any R, G, or B component of a premultiplied |
| // input color is non-zero and the A component is zero, the color is |
| // considered ill-formed, and the corresponding component of the blend result |
| // will be undefined. |
| // |
| // The weighting functions p0, p1, and p2 are defined as follows: |
| // |
| // p0(As,Ad) = As*Ad |
| // p1(As,Ad) = As*(1 - Ad) |
| // p2(As,Ad) = Ad*(1 - As) |
| // |
| // In these functions, the A components of the source and destination colors |
| // are taken to indicate the portion of the pixel covered by the fragment |
| // (source) and the fragments previously accumulated in the pixel |
| // (destination). The functions p0, p1, and p2 approximate the relative |
| // portion of the pixel covered by the intersection of the source and |
| // destination, covered only by the source, and covered only by the |
| // destination, respectively. The equations defined here assume that there |
| // is no correlation between the source and destination coverage. |
| // |
| |
| #ifdef @FRAGMENT |
| |
| #ifdef @ENABLE_KHR_BLEND |
| layout( |
| #ifdef @ENABLE_HSL_BLEND_MODES |
| blend_support_all_equations |
| #else |
| blend_support_multiply, |
| blend_support_screen, |
| blend_support_overlay, |
| blend_support_darken, |
| blend_support_lighten, |
| blend_support_colordodge, |
| blend_support_colorburn, |
| blend_support_hardlight, |
| blend_support_softlight, |
| blend_support_difference, |
| blend_support_exclusion |
| #endif |
| ) out; |
| #endif // ENABLE_KHR_BLEND |
| |
| #ifdef @ENABLE_ADVANCED_BLEND |
| #ifdef @ENABLE_HSL_BLEND_MODES |
| // Note: the following routines are mathematically equivalent to those in |
| // https://registry.khronos.org/OpenGL/extensions/KHR/KHR_blend_equation_advanced.txt |
| // but have been rearranged to be more efficient. |
| |
| // When using one of the HSL blend equations in table X.2 as the blend equation, |
| // the blend coefficients are effectively obtained by converting both the |
| // non-premultiplied source and destination colors to the HSL (hue, saturation, |
| // luminosity) color space, generating a new HSL color by selecting H, S, and L |
| // components from the source or destination according to the blend equation, |
| // and then converting the result back to RGB. The HSL blend equations are only |
| // well defined when the values of the input color components are in the range |
| // [0..1]. |
| half lum_from_rgb(half3 c) { return dot(c, make_half3(.30, .59, .11)); } |
| |
| // Take the base RGB color and override its luminosity with that of another |
| // RGB color (lumColor). |
| half3 set_lum(half3 baseColor, half3 lumColor) |
| { |
| half lumTarget = lum_from_rgb(lumColor); |
| |
| // Bias the color such that its original luminance is now the 0 point. |
| half3 biased = baseColor - lum_from_rgb(baseColor); |
| |
| // Now we potentially need to rescale the color to get it to fit within |
| // 0..1. Effectively to keep the relative luminance, we may need to squish |
| // the rgb range so it still fits. |
| |
| // Calculate the scale values necessary to push the min or max component |
| // back into range. One is for if the luminance pushes the rgb values |
| // negative (pushing min component back into range), the other for if they |
| // go above 1.0 (pushing max component). |
| half2 scales = |
| make_half2(lumTarget, 1.0 - lumTarget) / |
| max(make_half2(EPSILON_FP16_NON_DENORM), |
| make_half2(-min_component(biased), max_component(biased))); |
| |
| // Take the minimum scale of the above (but nothing larger than 1, since we |
| // only ever want to scale *down* the range) |
| half satScale = min(make_half(1.0), min(scales.x, scales.y)); |
| |
| // Now we can apply the scale to get the rgb range right, then re-bias it |
| // back into the correct place (at the new luminance) |
| return biased * satScale + lumTarget; |
| } |
| |
| // Take the hue from hueColor, the saturation from satColor, and the luminance |
| // from lumColor and combine them into one resulting color. |
| half3 set_lum_sat(half3 hueColor, half3 satColor, half3 lumColor) |
| { |
| // The saturation of a color is the difference between its max and min |
| // components. |
| float satTarget = max_component(satColor) - min_component(satColor); |
| |
| // Bias the hue color so its min component is 0 (this is not *strictly* |
| // required but it simplifies the saturation calculation and matches the |
| // canonical math). |
| hueColor -= min_component(hueColor); |
| |
| // Because of that bias, the minimum component is now 0, so the saturation |
| // is just the max component. |
| float satSource = max_component(hueColor); |
| |
| // Rescale hueColor to have the new saturation. If satSource == 0, then |
| // hueColor == {0, 0, 0}, so do a max on the denominator to avoid a divide |
| // by 0. |
| float scale = satTarget / max(EPSILON_FP16_NON_DENORM, satSource); |
| |
| // Now apply the luminance from lumColor to the rescaled color. |
| return set_lum(hueColor * scale, lumColor); |
| } |
| #endif // ENABLE_HSL_BLEND_MODES |
| |
| // The advanced blend coefficients are generated from un-multiplied RGB values, |
| // and control the look of each blend mode. |
| half3 advanced_blend_coeffs(half3 src, half4 dstPremul, ushort mode) |
| { |
| half3 dst = unmultiply_rgb(dstPremul); |
| half3 coeffs; |
| switch (mode) |
| { |
| case BLEND_MODE_MULTIPLY: |
| coeffs = src.rgb * dst.rgb; |
| break; |
| case BLEND_MODE_SCREEN: |
| coeffs = src.rgb + dst.rgb - src.rgb * dst.rgb; |
| break; |
| case BLEND_MODE_OVERLAY: |
| { |
| // This logic is equivalent to the following, but should be more |
| // efficient, and works around a Vulkan Adreno 6-series Android 9/10 |
| // driver bug: |
| // f(Cs,Cd) = 2*Cs*Cd, if Cd <= 0.5 |
| // 1-2*(1-Cs)*(1-Cd), otherwise |
| half3 sd = src * dst; |
| coeffs = 2.0 * mix(sd, |
| src + dst - sd - 0.5, |
| greaterThan(dst, make_half3(0.5))); |
| break; |
| } |
| case BLEND_MODE_DARKEN: |
| coeffs = min(src.rgb, dst.rgb); |
| break; |
| case BLEND_MODE_LIGHTEN: |
| coeffs = max(src.rgb, dst.rgb); |
| break; |
| case BLEND_MODE_COLORDODGE: |
| { |
| dstPremul.rgb = clamp(dstPremul.rgb, make_half3(.0), dstPremul.aaa); |
| half3 denom = |
| clamp(1. - src, make_half3(.0), make_half3(1.)) * dstPremul.a; |
| coeffs = mix(min(make_half3(1.), dstPremul.rgb / denom), |
| sign(dstPremul.rgb), |
| equal(denom, make_half3(.0))); |
| break; |
| } |
| case BLEND_MODE_COLORBURN: |
| { |
| src = clamp(src, make_half3(.0), make_half3(1.)); |
| dstPremul.rgb = clamp(dstPremul.rgb, make_half3(.0), dstPremul.aaa); |
| if (dstPremul.a == .0) |
| dstPremul.a = 1.; |
| half3 numer = dstPremul.a - dstPremul.rgb; |
| coeffs = 1. - mix(min(make_half3(1.), numer / (src * dstPremul.a)), |
| sign(numer), |
| equal(src, make_half3(.0))); |
| break; |
| } |
| case BLEND_MODE_HARDLIGHT: |
| { |
| // This logic is equivalent to the following, but should be more |
| // efficient, and works around a Vulkan Adreno 6-series Android 9/10 |
| // driver bug: |
| // f(Cs,Cd) = 2*Cs*Cd, if Cs <= 0.5 |
| // 1-2*(1-Cs)*(1-Cd), otherwise |
| half3 sd = src * dst; |
| coeffs = 2.0 * mix(sd, |
| src + dst - sd - 0.5, |
| greaterThan(src, make_half3(0.5))); |
| break; |
| } |
| case BLEND_MODE_SOFTLIGHT: |
| { |
| // This logic is equivalent to the following, but should be more |
| // efficient, and works around a Vulkan Adreno 6-series Android 9/10 |
| // driver bug: |
| // f(Cs,Cd) = |
| // Cd-(1-2*Cs)*Cd*(1-Cd), |
| // if Cs <= 0.5 |
| // Cd+(2*Cs-1)*Cd*((16*Cd-12)*Cd+3), |
| // if Cs > 0.5 and Cd <= 0.25 |
| // Cd+(2*Cs-1)*(sqrt(Cd)-Cd), |
| // if Cs > 0.5 and Cd > 0.25 |
| for (int i = 0; i < 3; ++i) |
| { |
| if (src[i] <= 0.5) |
| coeffs[i] = (1.0 - dst[i]); |
| else if (dst[i] <= 0.25) |
| coeffs[i] = ((16.0 * dst[i] - 12.0) * dst[i] + 3.0); |
| else |
| coeffs[i] = (inversesqrt(dst[i]) - 1.0); |
| } |
| |
| coeffs = dst + dst * (2.0 * src - 1.0) * coeffs; |
| break; |
| } |
| case BLEND_MODE_DIFFERENCE: |
| coeffs = abs(dst.rgb - src.rgb); |
| break; |
| case BLEND_MODE_EXCLUSION: |
| coeffs = src.rgb + dst.rgb - 2. * src.rgb * dst.rgb; |
| break; |
| #ifdef @ENABLE_HSL_BLEND_MODES |
| // The HSL blend equations are only well defined when the values of the |
| // input color components are in the range [0..1]. |
| case BLEND_MODE_HUE: |
| if (@ENABLE_HSL_BLEND_MODES) |
| { |
| src.rgb = clamp(src.rgb, make_half3(.0), make_half3(1.)); |
| coeffs = set_lum_sat(src.rgb, dst.rgb, dst.rgb); |
| } |
| break; |
| case BLEND_MODE_SATURATION: |
| if (@ENABLE_HSL_BLEND_MODES) |
| { |
| src.rgb = clamp(src.rgb, make_half3(.0), make_half3(1.)); |
| coeffs = set_lum_sat(dst.rgb, src.rgb, dst.rgb); |
| } |
| break; |
| case BLEND_MODE_COLOR: |
| if (@ENABLE_HSL_BLEND_MODES) |
| { |
| src.rgb = clamp(src.rgb, make_half3(.0), make_half3(1.)); |
| coeffs = set_lum(src.rgb, dst.rgb); |
| } |
| break; |
| case BLEND_MODE_LUMINOSITY: |
| if (@ENABLE_HSL_BLEND_MODES) |
| { |
| src.rgb = clamp(src.rgb, make_half3(.0), make_half3(1.)); |
| coeffs = set_lum(dst.rgb, src.rgb); |
| } |
| break; |
| #endif |
| } |
| return coeffs; |
| } |
| |
| // Performs the given advanced blend operation with a solid RGB src color (no |
| // srcAlpha). |
| // |
| // NOTE: This method is sufficient for all blending because alpha in the src |
| // can be accounted for afterward using a standard src-over blend operation. |
| // |
| // e.g., dst = blend_src_over( |
| // premultiply(advanced_color_blend(src.rgb, dstPremul)), |
| // dstPremul) |
| INLINE half3 advanced_color_blend(half3 src, half4 dstPremul, ushort mode) |
| { |
| // The weighting functions p0, p1, and p2 are defined as follows: |
| // |
| // p0(As,Ad) = As*Ad |
| // p1(As,Ad) = As*(1 - Ad) |
| // p2(As,Ad) = Ad*(1 - As) |
| // |
| // Since srcAlpha (As) == 1, this simplifies to: |
| // |
| // p0(As,Ad) = Ad |
| // p1(As,Ad) = (1 - Ad) |
| // p2(As,Ad) = 0 |
| // |
| // Blending is performed according to the following equations: |
| // |
| // R = coeffs(Rs',Rd')*p0 + Y*Rs'*p1 + Z*Rd'*p2 |
| // G = coeffs(Gs',Gd')*p0 + Y*Gs'*p1 + Z*Gd'*p2 |
| // B = coeffs(Bs',Bd')*p0 + Y*Bs'*p1 + Z*Bd'*p2 |
| // A = X*p0 + Y*p1 + Z*p2 |
| // |
| // NOTE: (X,Y,Z) always == 1, so it is ignored in this implementation. |
| // Also, since (X,Y,Z) == 1, alpha simplifies to standard src-over |
| // rules: A = Ad * (1 - As) + As |
| half3 coeffs = advanced_blend_coeffs(src, dstPremul, mode); |
| |
| // Because p0 is (Ad), p1 is (1 - Ad), and p2 is 0, this is equivalent to |
| // that matrix multiply: |
| return mix(src, coeffs, make_half3(dstPremul.a)); |
| } |
| #endif // ENABLE_ADVANCED_BLEND |
| |
| #endif // FRAGMENT |
