/*
 * Copyright 2013 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef GrBlend_DEFINED
#define GrBlend_DEFINED

#include "GrColor.h"
#include "../private/SkTLogic.h"

/**
 * Equations for alpha-blending.
 */
enum GrBlendEquation {
    // Basic blend equations.
    kAdd_GrBlendEquation,             //<! Cs*S + Cd*D
    kSubtract_GrBlendEquation,        //<! Cs*S - Cd*D
    kReverseSubtract_GrBlendEquation, //<! Cd*D - Cs*S

    // Advanced blend equations. These are described in the SVG and PDF specs.
    kScreen_GrBlendEquation,
    kOverlay_GrBlendEquation,
    kDarken_GrBlendEquation,
    kLighten_GrBlendEquation,
    kColorDodge_GrBlendEquation,
    kColorBurn_GrBlendEquation,
    kHardLight_GrBlendEquation,
    kSoftLight_GrBlendEquation,
    kDifference_GrBlendEquation,
    kExclusion_GrBlendEquation,
    kMultiply_GrBlendEquation,
    kHSLHue_GrBlendEquation,
    kHSLSaturation_GrBlendEquation,
    kHSLColor_GrBlendEquation,
    kHSLLuminosity_GrBlendEquation,

    kFirstAdvancedGrBlendEquation = kScreen_GrBlendEquation,
    kLast_GrBlendEquation = kHSLLuminosity_GrBlendEquation
};

static const int kGrBlendEquationCnt = kLast_GrBlendEquation + 1;


/**
 * Coefficients for alpha-blending.
 */
enum GrBlendCoeff {
    kZero_GrBlendCoeff,    //<! 0
    kOne_GrBlendCoeff,     //<! 1
    kSC_GrBlendCoeff,      //<! src color
    kISC_GrBlendCoeff,     //<! one minus src color
    kDC_GrBlendCoeff,      //<! dst color
    kIDC_GrBlendCoeff,     //<! one minus dst color
    kSA_GrBlendCoeff,      //<! src alpha
    kISA_GrBlendCoeff,     //<! one minus src alpha
    kDA_GrBlendCoeff,      //<! dst alpha
    kIDA_GrBlendCoeff,     //<! one minus dst alpha
    kConstC_GrBlendCoeff,  //<! constant color
    kIConstC_GrBlendCoeff, //<! one minus constant color
    kConstA_GrBlendCoeff,  //<! constant color alpha
    kIConstA_GrBlendCoeff, //<! one minus constant color alpha
    kS2C_GrBlendCoeff,
    kIS2C_GrBlendCoeff,
    kS2A_GrBlendCoeff,
    kIS2A_GrBlendCoeff,

    kLast_GrBlendCoeff = kIS2A_GrBlendCoeff
};

static const int kGrBlendCoeffCnt = kLast_GrBlendCoeff + 1;

/**
 * Given a known blend equation in the form of srcCoeff * srcColor + dstCoeff * dstColor where
 * there may be partial knowledge of the srcColor and dstColor component values, determine what
 * components of the blended output color are known. Coeffs must not refer to the constant or
 * secondary src color.
 */
void GrGetCoeffBlendKnownComponents(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff,
                                    GrColor srcColor,
                                    GrColorComponentFlags srcColorFlags,
                                    GrColor dstColor,
                                    GrColorComponentFlags dstColorFlags,
                                    GrColor* outColor,
                                    GrColorComponentFlags* outFlags);

template<GrBlendCoeff Coeff>
struct GrTBlendCoeffRefsSrc : skstd::bool_constant<kSC_GrBlendCoeff == Coeff ||
                                                   kISC_GrBlendCoeff == Coeff ||
                                                   kSA_GrBlendCoeff == Coeff ||
                                                   kISA_GrBlendCoeff == Coeff> {};

#define GR_BLEND_COEFF_REFS_SRC(COEFF) \
    GrTBlendCoeffRefsSrc<COEFF>::value

inline bool GrBlendCoeffRefsSrc(GrBlendCoeff coeff) {
    switch (coeff) {
        case kSC_GrBlendCoeff:
        case kISC_GrBlendCoeff:
        case kSA_GrBlendCoeff:
        case kISA_GrBlendCoeff:
            return true;
        default:
            return false;
    }
}

template<GrBlendCoeff Coeff>
struct GrTBlendCoeffRefsDst : skstd::bool_constant<kDC_GrBlendCoeff == Coeff ||
                                                   kIDC_GrBlendCoeff == Coeff ||
                                                   kDA_GrBlendCoeff == Coeff ||
                                                   kIDA_GrBlendCoeff == Coeff> {};

#define GR_BLEND_COEFF_REFS_DST(COEFF) \
    GrTBlendCoeffRefsDst<COEFF>::value

inline bool GrBlendCoeffRefsDst(GrBlendCoeff coeff) {
    switch (coeff) {
        case kDC_GrBlendCoeff:
        case kIDC_GrBlendCoeff:
        case kDA_GrBlendCoeff:
        case kIDA_GrBlendCoeff:
            return true;
        default:
            return false;
    }
}


template<GrBlendCoeff Coeff>
struct GrTBlendCoeffRefsSrc2 : skstd::bool_constant<kS2C_GrBlendCoeff == Coeff ||
                                                    kIS2C_GrBlendCoeff == Coeff ||
                                                    kS2A_GrBlendCoeff == Coeff ||
                                                    kIS2A_GrBlendCoeff == Coeff> {};

#define GR_BLEND_COEFF_REFS_SRC2(COEFF) \
    GrTBlendCoeffRefsSrc2<COEFF>::value

inline bool GrBlendCoeffRefsSrc2(GrBlendCoeff coeff) {
    switch (coeff) {
        case kS2C_GrBlendCoeff:
        case kIS2C_GrBlendCoeff:
        case kS2A_GrBlendCoeff:
        case kIS2A_GrBlendCoeff:
            return true;
        default:
            return false;
    }
}


template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
struct GrTBlendCoeffsUseSrcColor : skstd::bool_constant<kZero_GrBlendCoeff != SrcCoeff ||
                                                        GR_BLEND_COEFF_REFS_SRC(DstCoeff)> {};

#define GR_BLEND_COEFFS_USE_SRC_COLOR(SRC_COEFF, DST_COEFF) \
    GrTBlendCoeffsUseSrcColor<SRC_COEFF, DST_COEFF>::value


template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
struct GrTBlendCoeffsUseDstColor : skstd::bool_constant<GR_BLEND_COEFF_REFS_DST(SrcCoeff) ||
                                                        kZero_GrBlendCoeff != DstCoeff> {};

#define GR_BLEND_COEFFS_USE_DST_COLOR(SRC_COEFF, DST_COEFF) \
    GrTBlendCoeffsUseDstColor<SRC_COEFF, DST_COEFF>::value


template<GrBlendEquation Equation>
struct GrTBlendEquationIsAdvanced : skstd::bool_constant<Equation >= kFirstAdvancedGrBlendEquation> {};

#define GR_BLEND_EQUATION_IS_ADVANCED(EQUATION) \
    GrTBlendEquationIsAdvanced<EQUATION>::value

inline bool GrBlendEquationIsAdvanced(GrBlendEquation equation) {
    return equation >= kFirstAdvancedGrBlendEquation;
}


template<GrBlendEquation BlendEquation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
struct GrTBlendModifiesDst : skstd::bool_constant<
    (kAdd_GrBlendEquation != BlendEquation && kReverseSubtract_GrBlendEquation != BlendEquation) ||
     kZero_GrBlendCoeff != SrcCoeff ||
     kOne_GrBlendCoeff != DstCoeff> {};

#define GR_BLEND_MODIFIES_DST(EQUATION, SRC_COEFF, DST_COEFF) \
    GrTBlendModifiesDst<EQUATION, SRC_COEFF, DST_COEFF>::value


/**
 * Advanced blend equations can always tweak alpha for coverage. (See GrCustomXfermode.cpp)
 *
 * For "add" and "reverse subtract" the blend equation with f=coverage is:
 *
 *   D' = f * (S * srcCoeff + D * dstCoeff) + (1-f) * D
 *      = f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
 *
 * (Let srcCoeff be negative for reverse subtract.) We can tweak alpha for coverage when the
 * following relationship holds:
 *
 *   (f*S) * srcCoeff' + D * dstCoeff' == f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
 *
 * (Where srcCoeff' and dstCoeff' have any reference to S pre-multiplied by f.)
 *
 * It's easy to see this works for the src term as long as srcCoeff' == srcCoeff (meaning srcCoeff
 * does not reference S). For the dst term, this will work as long as the following is true:
 *|
 *   dstCoeff' == f * dstCoeff + (1 - f)
 *   dstCoeff' == 1 - f * (1 - dstCoeff)
 *
 * By inspection we can see this will work as long as dstCoeff has a 1, and any other term in
 * dstCoeff references S.
 *
 * Moreover, if the blend doesn't modify the dst at all then it is ok to arbitrarily modify the src
 * color so folding in coverage is allowed.
 */
template<GrBlendEquation Equation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
struct GrTBlendCanTweakAlphaForCoverage : skstd::bool_constant<
    GR_BLEND_EQUATION_IS_ADVANCED(Equation) ||
    ((kAdd_GrBlendEquation == Equation || kReverseSubtract_GrBlendEquation == Equation) &&
      !GR_BLEND_COEFF_REFS_SRC(SrcCoeff) &&
      (kOne_GrBlendCoeff == DstCoeff ||
       kISC_GrBlendCoeff == DstCoeff ||
       kISA_GrBlendCoeff == DstCoeff)) ||
    !GrTBlendModifiesDst<Equation, SrcCoeff, DstCoeff>::value> {};

#define GR_BLEND_CAN_TWEAK_ALPHA_FOR_COVERAGE(EQUATION, SRC_COEFF, DST_COEFF) \
    GrTBlendCanTweakAlphaForCoverage<EQUATION, SRC_COEFF, DST_COEFF>::value

#endif