_Private::AddGeneralOps< Traits, true > Struct Template Reference

#include <KoCompositeOps.h>

Public Types
typedef Traits::channels_type	Arg
typedef Arg(*	CompositeFunc) (Arg, Arg)

Static Public Member Functions
static void	add (KoColorSpace *cs)
template<CompositeFunc func>
static void	add (KoColorSpace *cs, const QString &id, const QString &category)
template<typename Functor >
static void	add (KoColorSpace *cs, const QString &id, const QString &category)

Static Public Attributes
static const qint32	alpha_pos = Traits::alpha_pos
static constexpr bool	IsIntegerSpace = std::numeric_limits<Arg>::is_integer

Detailed Description

template<class Traits>
struct _Private::AddGeneralOps< Traits, true >

Definition at line 131 of file KoCompositeOps.h.

Member Typedef Documentation

Arg

template<class Traits >

typedef Traits::channels_type _Private::AddGeneralOps< Traits, true >::Arg

Definition at line 133 of file KoCompositeOps.h.

CompositeFunc

template<class Traits >

typedef Arg(* _Private::AddGeneralOps< Traits, true >::CompositeFunc) (Arg, Arg)

Definition at line 134 of file KoCompositeOps.h.

Member Function Documentation

add() [1/3]

template<class Traits >

static void _Private::AddGeneralOps< Traits, true >::add ( KoColorSpace * cs )

inlinestatic

Definition at line 164 of file KoCompositeOps.h.

                                       {
         using namespace KoCompositeOpClampPolicy;
 
         cs->addCompositeOp(OptimizedOpsSelector<Traits>::createOverOp(cs));
         cs->addCompositeOp(OptimizedOpsSelector<Traits>::createAlphaDarkenOp(cs));
         cs->addCompositeOp(OptimizedOpsSelector<Traits>::createCopyOp(cs));
         cs->addCompositeOp(new KoCompositeOpErase<Traits>(cs));
 
         if constexpr (std::is_base_of_v<KoCmykTraits<typename Traits::channels_type>, Traits>) {
            if (useSubtractiveBlendingForCmykColorSpaces()) {
                cs->addCompositeOp(new KoCompositeOpBehind<Traits, KoSubtractiveBlendingPolicy<Traits>>(cs));
            } else {
                cs->addCompositeOp(new KoCompositeOpBehind<Traits, KoAdditiveBlendingPolicy<Traits>>(cs));
            }
         } else {
            cs->addCompositeOp(new KoCompositeOpBehind<Traits, KoAdditiveBlendingPolicy<Traits>>(cs));
         }
 
         cs->addCompositeOp(new KoCompositeOpDestinationIn<Traits>(cs));
         cs->addCompositeOp(new KoCompositeOpDestinationAtop<Traits>(cs));
 
         if constexpr (std::is_base_of_v<KoCmykTraits<typename Traits::channels_type>, Traits>) {
            if (useSubtractiveBlendingForCmykColorSpaces()) {
                cs->addCompositeOp(new KoCompositeOpGreater<Traits, KoSubtractiveBlendingPolicy<Traits>>(cs));
            } else {
                cs->addCompositeOp(new KoCompositeOpGreater<Traits, KoAdditiveBlendingPolicy<Traits>>(cs));
            }
         } else {
            cs->addCompositeOp(new KoCompositeOpGreater<Traits, KoAdditiveBlendingPolicy<Traits>>(cs));
         }
 
         add<CFOverlay<Arg>        >(cs, COMPOSITE_OVERLAY       , KoCompositeOp::categoryMix());
         add<CFGrainMerge<Arg>     >(cs, COMPOSITE_GRAIN_MERGE   , KoCompositeOp::categoryMix());
         add<CFGrainExtract<Arg>   >(cs, COMPOSITE_GRAIN_EXTRACT , KoCompositeOp::categoryMix());
         add<FunctorWithSDRClampPolicy<CFHardMix, Arg>>(cs, COMPOSITE_HARD_MIX, KoCompositeOp::categoryMix());
         if constexpr (!IsIntegerSpace) {
             add<CFHardMix<Arg, ClampAsFloatHDR>>(cs, COMPOSITE_HARD_MIX_HDR, KoCompositeOp::categoryMix());
         }
 
         add<CFHardMixPhotoshop<Arg>>(cs, COMPOSITE_HARD_MIX_PHOTOSHOP, KoCompositeOp::categoryMix());
         add<CFHardMixSofterPhotoshop<Arg>>(cs, COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP, KoCompositeOp::categoryMix());
         add<CFGeometricMean<Arg>  >(cs, COMPOSITE_GEOMETRIC_MEAN, KoCompositeOp::categoryMix());
         add<CFParallel<Arg>       >(cs, COMPOSITE_PARALLEL      , KoCompositeOp::categoryMix());
         add<&cfAllanon<Arg>       >(cs, COMPOSITE_ALLANON       , KoCompositeOp::categoryMix());
         add<FunctorWithSDRClampPolicy<CFHardOverlay, Arg>>(cs, COMPOSITE_HARD_OVERLAY, KoCompositeOp::categoryMix());
         if constexpr (!IsIntegerSpace) {
             add<CFHardOverlay<Arg, ClampAsFloatHDR>>(cs, COMPOSITE_HARD_OVERLAY_HDR, KoCompositeOp::categoryMix());
         }
 
         add<&cfInterpolation<Arg> >(cs, COMPOSITE_INTERPOLATION , KoCompositeOp::categoryMix());
         add<&cfInterpolationB<Arg>>(cs, COMPOSITE_INTERPOLATIONB, KoCompositeOp::categoryMix());
         add<CFPenumbraA<Arg>      >(cs, COMPOSITE_PENUMBRAA     , KoCompositeOp::categoryMix());
         add<CFPenumbraB<Arg>      >(cs, COMPOSITE_PENUMBRAB     , KoCompositeOp::categoryMix());
         add<&cfPenumbraC<Arg>     >(cs, COMPOSITE_PENUMBRAC     , KoCompositeOp::categoryMix());
         add<&cfPenumbraD<Arg>     >(cs, COMPOSITE_PENUMBRAD     , KoCompositeOp::categoryMix());
         cs->addCompositeOp(new KoCompositeOpMarker<Traits>(cs));
 
         add<&cfScreen<Arg>      >(cs, COMPOSITE_SCREEN      , KoCompositeOp::categoryLight());
 
         add<FunctorWithSDRClampPolicy<CFColorDodge, Arg>>(cs, COMPOSITE_DODGE, KoCompositeOp::categoryLight());
         if constexpr (!IsIntegerSpace) {
             add<CFColorDodge<Arg, ClampAsFloatHDR>>(cs, COMPOSITE_DODGE_HDR, KoCompositeOp::categoryLight());
         }
 
         add<&cfAddition<Arg>    >(cs, COMPOSITE_LINEAR_DODGE, KoCompositeOp::categoryLight());
         add<&cfLightenOnly<Arg> >(cs, COMPOSITE_LIGHTEN     , KoCompositeOp::categoryLight());
         add<CFHardLight<Arg>    >(cs, COMPOSITE_HARD_LIGHT  , KoCompositeOp::categoryLight());
         add<&cfSoftLightIFSIllusions<Arg>>(cs, COMPOSITE_SOFT_LIGHT_IFS_ILLUSIONS, KoCompositeOp::categoryLight());
         add<&cfSoftLightPegtopDelphi<Arg>>(cs, COMPOSITE_SOFT_LIGHT_PEGTOP_DELPHI, KoCompositeOp::categoryLight());
         add<CFSoftLightSvg<Arg> >(cs, COMPOSITE_SOFT_LIGHT_SVG, KoCompositeOp::categoryLight());
         add<CFSoftLight<Arg>    >(cs, COMPOSITE_SOFT_LIGHT_PHOTOSHOP, KoCompositeOp::categoryLight());
         add<CFGammaLight<Arg>   >(cs, COMPOSITE_GAMMA_LIGHT , KoCompositeOp::categoryLight());
         add<CFGammaIllumination<Arg>>(cs, COMPOSITE_GAMMA_ILLUMINATION, KoCompositeOp::categoryLight());
 
         add<FunctorWithSDRClampPolicy<CFVividLight, Arg>>(cs, COMPOSITE_VIVID_LIGHT, KoCompositeOp::categoryLight());
         if constexpr (!IsIntegerSpace) {
             add<CFVividLight<Arg, ClampAsFloatHDR>>(cs, COMPOSITE_VIVID_LIGHT_HDR, KoCompositeOp::categoryLight());
         }
         add<CFFlatLight<Arg>    >(cs, COMPOSITE_FLAT_LIGHT  , KoCompositeOp::categoryLight());
         add<CFPinLight<Arg>>(cs, COMPOSITE_PIN_LIGHT, KoCompositeOp::categoryLight()); // using HDR mode as default
         add<&cfLinearLight<Arg> >(cs, COMPOSITE_LINEAR_LIGHT, KoCompositeOp::categoryLight());
         add<&cfPNormA<Arg>      >(cs, COMPOSITE_PNORM_A     , KoCompositeOp::categoryLight());
         add<&cfPNormB<Arg>      >(cs, COMPOSITE_PNORM_B     , KoCompositeOp::categoryLight());
         add<&cfSuperLight<Arg>  >(cs, COMPOSITE_SUPER_LIGHT , KoCompositeOp::categoryLight());
         add<&cfTintIFSIllusions<Arg>>(cs, COMPOSITE_TINT_IFS_ILLUSIONS, KoCompositeOp::categoryLight());
         add<&cfFogLightenIFSIllusions<Arg>>(cs, COMPOSITE_FOG_LIGHTEN_IFS_ILLUSIONS, KoCompositeOp::categoryLight());
         add<&cfEasyDodge<Arg>   >(cs, COMPOSITE_EASY_DODGE  , KoCompositeOp::categoryLight());
 
         add<CFColorBurn<Arg>>(cs, COMPOSITE_BURN, KoCompositeOp::categoryDark()); // using HDR mode as default
         add<CFLinearBurn<Arg, ClampAsFloatHDR>>(cs, COMPOSITE_LINEAR_BURN , KoCompositeOp::categoryDark()); // using HDR mode as default
         add<&cfDarkenOnly<Arg> >(cs, COMPOSITE_DARKEN      , KoCompositeOp::categoryDark());
         add<CFGammaDark<Arg>   >(cs, COMPOSITE_GAMMA_DARK  , KoCompositeOp::categoryDark());
         add<&cfShadeIFSIllusions<Arg>>(cs, COMPOSITE_SHADE_IFS_ILLUSIONS, KoCompositeOp::categoryDark());
         add<&cfFogDarkenIFSIllusions<Arg>>(cs, COMPOSITE_FOG_DARKEN_IFS_ILLUSIONS, KoCompositeOp::categoryDark());
         add<&cfEasyBurn<Arg>   >(cs, COMPOSITE_EASY_BURN   , KoCompositeOp::categoryDark());
 
         add<&cfAddition<Arg>        >(cs, COMPOSITE_ADD             , KoCompositeOp::categoryArithmetic());
         add<&cfSubtract<Arg>        >(cs, COMPOSITE_SUBTRACT        , KoCompositeOp::categoryArithmetic());
         add<CFInverseSubtract<Arg>  >(cs, COMPOSITE_INVERSE_SUBTRACT, KoCompositeOp::categoryArithmetic());
         add<&cfMultiply<Arg>        >(cs, COMPOSITE_MULT            , KoCompositeOp::categoryArithmetic());
         add<CFDivide<Arg>           >(cs, COMPOSITE_DIVIDE          , KoCompositeOp::categoryArithmetic());
 
         add<&cfModulo<Arg>               >(cs, COMPOSITE_MOD                , KoCompositeOp::categoryModulo());
         add<&cfModuloContinuous<Arg>     >(cs, COMPOSITE_MOD_CON            , KoCompositeOp::categoryModulo());
         add<&cfDivisiveModulo<Arg>       >(cs, COMPOSITE_DIVISIVE_MOD       , KoCompositeOp::categoryModulo());
         add<&cfDivisiveModuloContinuous<Arg>>(cs, COMPOSITE_DIVISIVE_MOD_CON, KoCompositeOp::categoryModulo());
         add<&cfModuloShift<Arg>          >(cs, COMPOSITE_MODULO_SHIFT       , KoCompositeOp::categoryModulo());
         add<&cfModuloShiftContinuous<Arg>>(cs, COMPOSITE_MODULO_SHIFT_CON   , KoCompositeOp::categoryModulo());
 
         add<&cfArcTangent<Arg>         >(cs, COMPOSITE_ARC_TANGENT         , KoCompositeOp::categoryNegative());
         add<&cfDifference<Arg>         >(cs, COMPOSITE_DIFF                , KoCompositeOp::categoryNegative());
         add<CFExclusion<Arg>           >(cs, COMPOSITE_EXCLUSION           , KoCompositeOp::categoryNegative());
         add<CFEquivalence<Arg>         >(cs, COMPOSITE_EQUIVALENCE         , KoCompositeOp::categoryNegative());
         add<CFAdditiveSubtractive<Arg> >(cs, COMPOSITE_ADDITIVE_SUBTRACTIVE, KoCompositeOp::categoryNegative());
         add<CFNegation<Arg>            >(cs, COMPOSITE_NEGATION            , KoCompositeOp::categoryNegative());
         
         if constexpr (IsIntegerSpace) {
             add<&cfXor<Arg>        >(cs, COMPOSITE_XOR            , KoCompositeOp::categoryBinary());
             add<&cfOr<Arg>         >(cs, COMPOSITE_OR             , KoCompositeOp::categoryBinary());
             add<&cfAnd<Arg>        >(cs, COMPOSITE_AND            , KoCompositeOp::categoryBinary());
             add<&cfNand<Arg>       >(cs, COMPOSITE_NAND           , KoCompositeOp::categoryBinary());
             add<&cfNor<Arg>        >(cs, COMPOSITE_NOR            , KoCompositeOp::categoryBinary());
             add<&cfXnor<Arg>       >(cs, COMPOSITE_XNOR           , KoCompositeOp::categoryBinary());
             add<&cfImplies<Arg>    >(cs, COMPOSITE_IMPLICATION    , KoCompositeOp::categoryBinary());
             add<&cfNotImplies<Arg> >(cs, COMPOSITE_NOT_IMPLICATION, KoCompositeOp::categoryBinary());
             add<&cfConverse<Arg>   >(cs, COMPOSITE_CONVERSE       , KoCompositeOp::categoryBinary());
             add<&cfNotConverse<Arg>>(cs, COMPOSITE_NOT_CONVERSE   , KoCompositeOp::categoryBinary());
         }
 
         add<&cfReflect<Arg>>(cs, COMPOSITE_REFLECT, KoCompositeOp::categoryQuadratic());
         add<&cfGlow<Arg>   >(cs, COMPOSITE_GLOW   , KoCompositeOp::categoryQuadratic());
         add<&cfFreeze<Arg> >(cs, COMPOSITE_FREEZE , KoCompositeOp::categoryQuadratic());
         add<&cfHeat<Arg>   >(cs, COMPOSITE_HEAT   , KoCompositeOp::categoryQuadratic());
         add<CFGleat<Arg>   >(cs, COMPOSITE_GLEAT  , KoCompositeOp::categoryQuadratic());
         add<CFHelow<Arg>   >(cs, COMPOSITE_HELOW  , KoCompositeOp::categoryQuadratic());
         add<CFReeze<Arg>   >(cs, COMPOSITE_REEZE  , KoCompositeOp::categoryQuadratic());
         add<CFFrect<Arg>   >(cs, COMPOSITE_FRECT  , KoCompositeOp::categoryQuadratic());
         add<&cfFhyrd<Arg>  >(cs, COMPOSITE_FHYRD  , KoCompositeOp::categoryQuadratic());
 
         cs->addCompositeOp(new KoCompositeOpDissolve<Traits>(cs, KoCompositeOp::categoryMisc()));
     }

References KoColorSpace::addCompositeOp(), KoCompositeOp::categoryArithmetic(), KoCompositeOp::categoryBinary(), KoCompositeOp::categoryDark(), KoCompositeOp::categoryLight(), KoCompositeOp::categoryMisc(), KoCompositeOp::categoryMix(), KoCompositeOp::categoryModulo(), KoCompositeOp::categoryNegative(), KoCompositeOp::categoryQuadratic(), COMPOSITE_ADD, COMPOSITE_ADDITIVE_SUBTRACTIVE, COMPOSITE_ALLANON, COMPOSITE_AND, COMPOSITE_ARC_TANGENT, COMPOSITE_BURN, COMPOSITE_CONVERSE, COMPOSITE_DARKEN, COMPOSITE_DIFF, COMPOSITE_DIVIDE, COMPOSITE_DIVISIVE_MOD, COMPOSITE_DIVISIVE_MOD_CON, COMPOSITE_DODGE, COMPOSITE_DODGE_HDR, COMPOSITE_EASY_BURN, COMPOSITE_EASY_DODGE, COMPOSITE_EQUIVALENCE, COMPOSITE_EXCLUSION, COMPOSITE_FHYRD, COMPOSITE_FLAT_LIGHT, COMPOSITE_FOG_DARKEN_IFS_ILLUSIONS, COMPOSITE_FOG_LIGHTEN_IFS_ILLUSIONS, COMPOSITE_FRECT, COMPOSITE_FREEZE, COMPOSITE_GAMMA_DARK, COMPOSITE_GAMMA_ILLUMINATION, COMPOSITE_GAMMA_LIGHT, COMPOSITE_GEOMETRIC_MEAN, COMPOSITE_GLEAT, COMPOSITE_GLOW, COMPOSITE_GRAIN_EXTRACT, COMPOSITE_GRAIN_MERGE, COMPOSITE_HARD_LIGHT, COMPOSITE_HARD_MIX, COMPOSITE_HARD_MIX_HDR, COMPOSITE_HARD_MIX_PHOTOSHOP, COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP, COMPOSITE_HARD_OVERLAY, COMPOSITE_HARD_OVERLAY_HDR, COMPOSITE_HEAT, COMPOSITE_HELOW, COMPOSITE_IMPLICATION, COMPOSITE_INTERPOLATION, COMPOSITE_INTERPOLATIONB, COMPOSITE_INVERSE_SUBTRACT, COMPOSITE_LIGHTEN, COMPOSITE_LINEAR_BURN, COMPOSITE_LINEAR_DODGE, COMPOSITE_LINEAR_LIGHT, COMPOSITE_MOD, COMPOSITE_MOD_CON, COMPOSITE_MODULO_SHIFT, COMPOSITE_MODULO_SHIFT_CON, COMPOSITE_MULT, COMPOSITE_NAND, COMPOSITE_NEGATION, COMPOSITE_NOR, COMPOSITE_NOT_CONVERSE, COMPOSITE_NOT_IMPLICATION, COMPOSITE_OR, COMPOSITE_OVERLAY, COMPOSITE_PARALLEL, COMPOSITE_PENUMBRAA, COMPOSITE_PENUMBRAB, COMPOSITE_PENUMBRAC, COMPOSITE_PENUMBRAD, COMPOSITE_PIN_LIGHT, COMPOSITE_PNORM_A, COMPOSITE_PNORM_B, COMPOSITE_REEZE, COMPOSITE_REFLECT, COMPOSITE_SCREEN, COMPOSITE_SHADE_IFS_ILLUSIONS, COMPOSITE_SOFT_LIGHT_IFS_ILLUSIONS, COMPOSITE_SOFT_LIGHT_PEGTOP_DELPHI, COMPOSITE_SOFT_LIGHT_PHOTOSHOP, COMPOSITE_SOFT_LIGHT_SVG, COMPOSITE_SUBTRACT, COMPOSITE_SUPER_LIGHT, COMPOSITE_TINT_IFS_ILLUSIONS, COMPOSITE_VIVID_LIGHT, COMPOSITE_VIVID_LIGHT_HDR, COMPOSITE_XNOR, COMPOSITE_XOR, and useSubtractiveBlendingForCmykColorSpaces().

add() [2/3]

template<class Traits >

template<CompositeFunc func>

static void _Private::AddGeneralOps< Traits, true >::add ( KoColorSpace * cs, const QString & id, const QString & category )

inlinestatic

Definition at line 139 of file KoCompositeOps.h.

                                                                                   {
        if constexpr (std::is_base_of_v<KoCmykTraits<typename Traits::channels_type>, Traits>) {
            if (useSubtractiveBlendingForCmykColorSpaces()) {
                cs->addCompositeOp(new KoCompositeOpGenericSC<Traits, func, KoSubtractiveBlendingPolicy<Traits>>(cs, id, category));
            } else {
                cs->addCompositeOp(new KoCompositeOpGenericSC<Traits, func, KoAdditiveBlendingPolicy<Traits>>(cs, id, category));
            }
        } else {
            cs->addCompositeOp(new KoCompositeOpGenericSC<Traits, func, KoAdditiveBlendingPolicy<Traits>>(cs, id, category));
        }
     }

References KoColorSpace::addCompositeOp(), and useSubtractiveBlendingForCmykColorSpaces().

add() [3/3]

template<class Traits >

template<typename Functor >

static void _Private::AddGeneralOps< Traits, true >::add ( KoColorSpace * cs, const QString & id, const QString & category )

inlinestatic

Definition at line 152 of file KoCompositeOps.h.

                                                                                   {
         if constexpr (std::is_base_of_v<KoCmykTraits<typename Traits::channels_type>, Traits>) {
             if (useSubtractiveBlendingForCmykColorSpaces()) {
                 cs->addCompositeOp(new KoCompositeOpGenericSCFunctor<Traits, Functor, KoSubtractiveBlendingPolicy<Traits>>(cs, id, category));
             } else {
                 cs->addCompositeOp(new KoCompositeOpGenericSCFunctor<Traits, Functor, KoAdditiveBlendingPolicy<Traits>>(cs, id, category));
             }
         } else {
             cs->addCompositeOp(new KoCompositeOpGenericSCFunctor<Traits, Functor, KoAdditiveBlendingPolicy<Traits>>(cs, id, category));
         }
     }

References KoColorSpace::addCompositeOp(), and useSubtractiveBlendingForCmykColorSpaces().

Member Data Documentation

alpha_pos

template<class Traits >

const qint32 _Private::AddGeneralOps< Traits, true >::alpha_pos = Traits::alpha_pos

static

Definition at line 135 of file KoCompositeOps.h.

IsIntegerSpace

template<class Traits >

constexpr bool _Private::AddGeneralOps< Traits, true >::IsIntegerSpace = std::numeric_limits<Arg>::is_integer

staticconstexpr

Definition at line 136 of file KoCompositeOps.h.

---

The documentation for this struct was generated from the following file:

• libs/pigment/compositeops/KoCompositeOps.h