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