LCOV - app.info - gfx/skia/include/core/SkXfermode.h

LCOV - code coverage report
| Current view: | directory - gfx/skia/include/core - SkXfermode.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 11 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 10 | 0 | 0.0 %

           1                 :
           2                 : /*
           3                 :  * Copyright 2006 The Android Open Source Project
           4                 :  *
           5                 :  * Use of this source code is governed by a BSD-style license that can be
           6                 :  * found in the LICENSE file.
           7                 :  */
           8                 :
           9                 :
          10                 : #ifndef SkXfermode_DEFINED
          11                 : #define SkXfermode_DEFINED
          12                 :
          13                 : #include "SkFlattenable.h"
          14                 : #include "SkColor.h"
          15                 :
          16                 : /** \class SkXfermode
          17                 :
          18                 :     SkXfermode is the base class for objects that are called to implement custom
          19                 :     "transfer-modes" in the drawing pipeline. The static function Create(Modes)
          20                 :     can be called to return an instance of any of the predefined subclasses as
          21                 :     specified in the Modes enum. When an SkXfermode is assigned to an SkPaint,
          22                 :     then objects drawn with that paint have the xfermode applied.
          23                 : */
          24               0 : class SK_API SkXfermode : public SkFlattenable {
          25                 : public:
          26               0 :     SkXfermode() {}
          27                 :
          28                 :     virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
          29                 :                         const SkAlpha aa[]);
          30                 :     virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
          31                 :                         const SkAlpha aa[]);
          32                 :     virtual void xfer4444(uint16_t dst[], const SkPMColor src[], int count,
          33                 :                           const SkAlpha aa[]);
          34                 :     virtual void xferA8(SkAlpha dst[], const SkPMColor src[], int count,
          35                 :                         const SkAlpha aa[]);
          36                 :
          37                 :     /** Enum of possible coefficients to describe some xfermodes
          38                 :      */
          39                 :     enum Coeff {
          40                 :         kZero_Coeff,    /** 0 */
          41                 :         kOne_Coeff,     /** 1 */
          42                 :         kSC_Coeff,      /** src color */
          43                 :         kISC_Coeff,     /** inverse src color (i.e. 1 - sc) */
          44                 :         kDC_Coeff,      /** dst color */
          45                 :         kIDC_Coeff,     /** inverse dst color (i.e. 1 - dc) */
          46                 :         kSA_Coeff,      /** src alpha */
          47                 :         kISA_Coeff,     /** inverse src alpha (i.e. 1 - sa) */
          48                 :         kDA_Coeff,      /** dst alpha */
          49                 :         kIDA_Coeff,     /** inverse dst alpha (i.e. 1 - da) */
          50                 :
          51                 :         kCoeffCount
          52                 :     };
          53                 :
          54                 :     /** If the xfermode can be expressed as an equation using the coefficients
          55                 :         in Coeff, then asCoeff() returns true, and sets (if not null) src and
          56                 :         dst accordingly.
          57                 :
          58                 :             result = src_coeff * src_color + dst_coeff * dst_color;
          59                 :
          60                 :         As examples, here are some of the porterduff coefficients
          61                 :
          62                 :         MODE        SRC_COEFF       DST_COEFF
          63                 :         clear       zero            zero
          64                 :         src         one             zero
          65                 :         dst         zero            one
          66                 :         srcover     one             isa
          67                 :         dstover     ida             one
          68                 :      */
          69                 :     virtual bool asCoeff(Coeff* src, Coeff* dst);
          70                 :
          71                 :     /**
          72                 :      *  The same as calling xfermode->asCoeff(..), except that this also checks
          73                 :      *  if the xfermode is NULL, and if so, treats its as kSrcOver_Mode.
          74                 :      */
          75                 :     static bool AsCoeff(SkXfermode*, Coeff* src, Coeff* dst);
          76                 :
          77                 :     /** List of predefined xfermodes.
          78                 :         The algebra for the modes uses the following symbols:
          79                 :         Sa, Sc  - source alpha and color
          80                 :         Da, Dc - destination alpha and color (before compositing)
          81                 :         [a, c] - Resulting (alpha, color) values
          82                 :         For these equations, the colors are in premultiplied state.
          83                 :         If no xfermode is specified, kSrcOver is assumed.
          84                 :      */
          85                 :     enum Mode {
          86                 :         kClear_Mode,    //!< [0, 0]
          87                 :         kSrc_Mode,      //!< [Sa, Sc]
          88                 :         kDst_Mode,      //!< [Da, Dc]
          89                 :         kSrcOver_Mode,  //!< [Sa + Da - Sa*Da, Rc = Sc + (1 - Sa)*Dc]
          90                 :         kDstOver_Mode,  //!< [Sa + Da - Sa*Da, Rc = Dc + (1 - Da)*Sc]
          91                 :         kSrcIn_Mode,    //!< [Sa * Da, Sc * Da]
          92                 :         kDstIn_Mode,    //!< [Sa * Da, Sa * Dc]
          93                 :         kSrcOut_Mode,   //!< [Sa * (1 - Da), Sc * (1 - Da)]
          94                 :         kDstOut_Mode,   //!< [Da * (1 - Sa), Dc * (1 - Sa)]
          95                 :         kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
          96                 :         kDstATop_Mode,  //!< [Sa, Sa * Dc + Sc * (1 - Da)]
          97                 :         kXor_Mode,      //!< [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
          98                 :
          99                 :         // all remaining modes are defined in the SVG Compositing standard
         100                 :         // http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/
         101                 :         kPlus_Mode,
         102                 :         kMultiply_Mode,
         103                 :
         104                 :         // all above modes can be expressed as pair of src/dst Coeffs
         105                 :         kCoeffModesCnt,
         106                 :
         107                 :         kScreen_Mode = kCoeffModesCnt,
         108                 :         kOverlay_Mode,
         109                 :         kDarken_Mode,
         110                 :         kLighten_Mode,
         111                 :         kColorDodge_Mode,
         112                 :         kColorBurn_Mode,
         113                 :         kHardLight_Mode,
         114                 :         kSoftLight_Mode,
         115                 :         kDifference_Mode,
         116                 :         kExclusion_Mode,
         117                 :
         118                 :         kLastMode = kExclusion_Mode
         119                 :     };
         120                 :
         121                 :     /**
         122                 :      *  If the xfermode is one of the modes in the Mode enum, then asMode()
         123                 :      *  returns true and sets (if not null) mode accordingly. Otherwise it
         124                 :      *  returns false and ignores the mode parameter.
         125                 :      */
         126                 :     virtual bool asMode(Mode* mode);
         127                 :
         128                 :     /**
         129                 :      *  The same as calling xfermode->asMode(mode), except that this also checks
         130                 :      *  if the xfermode is NULL, and if so, treats its as kSrcOver_Mode.
         131                 :      */
         132                 :     static bool AsMode(SkXfermode*, Mode* mode);
         133                 :
         134                 :     /**
         135                 :      *  Returns true if the xfermode claims to be the specified Mode. This works
         136                 :      *  correctly even if the xfermode is NULL (which equates to kSrcOver.) Thus
         137                 :      *  you can say this without checking for a null...
         138                 :      *
         139                 :      *  If (SkXfermode::IsMode(paint.getXfermode(),
         140                 :      *                         SkXfermode::kDstOver_Mode)) {
         141                 :      *      ...
         142                 :      *  }
         143                 :      */
         144                 :     static bool IsMode(SkXfermode* xfer, Mode mode);
         145                 :
         146                 :     /** Return an SkXfermode object for the specified mode.
         147                 :      */
         148                 :     static SkXfermode* Create(Mode mode);
         149                 :
         150                 :     /** Return a function pointer to a routine that applies the specified
         151                 :         porter-duff transfer mode.
         152                 :      */
         153                 :     static SkXfermodeProc GetProc(Mode mode);
         154                 :
         155                 :     /** Return a function pointer to a routine that applies the specified
         156                 :         porter-duff transfer mode and srcColor to a 16bit device color. Note,
         157                 :         if the mode+srcColor might return a non-opaque color, then there is not
         158                 :         16bit proc, and this will return NULL.
         159                 :       */
         160                 :     static SkXfermodeProc16 GetProc16(Mode mode, SkColor srcColor);
         161                 :
         162                 :     /**
         163                 :      *  If the specified mode can be represented by a pair of Coeff, then return
         164                 :      *  true and set (if not NULL) the corresponding coeffs. If the mode is
         165                 :      *  not representable as a pair of Coeffs, return false and ignore the
         166                 :      *  src and dst parameters.
         167                 :      */
         168                 :     static bool ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst);
         169                 :
         170                 :     // DEPRECATED: call AsMode(...)
         171                 :     static bool IsMode(SkXfermode* xfer, Mode* mode) {
         172                 :         return AsMode(xfer, mode);
         173                 :     }
         174                 :
         175                 :     SK_DECLARE_FLATTENABLE_REGISTRAR()
         176                 : protected:
         177               0 :     SkXfermode(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
         178                 :
         179                 :     /** The default implementation of xfer32/xfer16/xferA8 in turn call this
         180                 :         method, 1 color at a time (upscaled to a SkPMColor). The default
         181                 :         implmentation of this method just returns dst. If performance is
         182                 :         important, your subclass should override xfer32/xfer16/xferA8 directly.
         183                 :
         184                 :         This method will not be called directly by the client, so it need not
         185                 :         be implemented if your subclass has overridden xfer32/xfer16/xferA8
         186                 :     */
         187                 :     virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst);
         188                 :
         189                 : private:
         190                 :     enum {
         191                 :         kModeCount = kLastMode + 1
         192                 :     };
         193                 :     typedef SkFlattenable INHERITED;
         194                 : };
         195                 :
         196                 : ///////////////////////////////////////////////////////////////////////////////
         197                 :
         198                 : /** \class SkProcXfermode
         199                 :
         200                 :     SkProcXfermode is a xfermode that applies the specified proc to its colors.
         201                 :     This class is not exported to java.
         202                 : */
         203               0 : class SkProcXfermode : public SkXfermode {
         204                 : public:
         205               0 :     SkProcXfermode(SkXfermodeProc proc) : fProc(proc) {}
         206                 :
         207                 :     // overrides from SkXfermode
         208                 :     virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
         209                 :                         const SkAlpha aa[]) SK_OVERRIDE;
         210                 :     virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
         211                 :                         const SkAlpha aa[]) SK_OVERRIDE;
         212                 :     virtual void xfer4444(uint16_t dst[], const SkPMColor src[], int count,
         213                 :                           const SkAlpha aa[]) SK_OVERRIDE;
         214                 :     virtual void xferA8(SkAlpha dst[], const SkPMColor src[], int count,
         215                 :                         const SkAlpha aa[]) SK_OVERRIDE;
         216                 :
         217                 :     // overrides from SkFlattenable
         218               0 :     virtual Factory getFactory() SK_OVERRIDE { return CreateProc; }
         219                 :     virtual void    flatten(SkFlattenableWriteBuffer&) SK_OVERRIDE;
         220                 :
         221                 : protected:
         222                 :     SkProcXfermode(SkFlattenableReadBuffer&);
         223                 :
         224                 :     // allow subclasses to update this after we unflatten
         225               0 :     void setProc(SkXfermodeProc proc) {
         226               0 :         fProc = proc;
         227               0 :     }
         228                 :
         229                 : private:
         230                 :     SkXfermodeProc  fProc;
         231                 :
         232               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         233               0 :         return SkNEW_ARGS(SkProcXfermode, (buffer)); }
         234                 :
         235                 :     typedef SkXfermode INHERITED;
         236                 : };
         237                 :
         238                 : #endif

Generated by: LCOV version 1.7