Home | History | Annotate | Download | only in effects 
      1 /*
      2  * Copyright 2011 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef SkLayerDrawLooper_DEFINED
      9 #define SkLayerDrawLooper_DEFINED
     10 
     11 #include "SkDrawLooper.h"
     12 #include "SkPaint.h"
     13 #include "SkPoint.h"
     14 #include "SkXfermode.h"
     15 
     16 class SK_API SkLayerDrawLooper : public SkDrawLooper {
     17 public:
     18     SK_DECLARE_INST_COUNT(SkLayerDrawLooper)
     19 
     20     virtual ~SkLayerDrawLooper();
     21 
     22     /**
     23      *  Bits specifies which aspects of the layer's paint should replace the
     24      *  corresponding aspects on the draw's paint.
     25      *  kEntirePaint_Bits means use the layer's paint completely.
     26      *  0 means ignore the layer's paint... except for fColorMode, which is
     27      *  always applied.
     28      */
     29     enum Bits {
     30         kStyle_Bit      = 1 << 0,   //!< use this layer's Style/stroke settings
     31         kTextSkewX_Bit  = 1 << 1,   //!< use this layer's textskewx
     32         kPathEffect_Bit = 1 << 2,   //!< use this layer's patheffect
     33         kMaskFilter_Bit = 1 << 3,   //!< use this layer's maskfilter
     34         kShader_Bit     = 1 << 4,   //!< use this layer's shader
     35         kColorFilter_Bit = 1 << 5,  //!< use this layer's colorfilter
     36         kXfermode_Bit   = 1 << 6,   //!< use this layer's xfermode
     37 
     38         /**
     39          *  Use the layer's paint entirely, with these exceptions:
     40          *  - We never override the draw's paint's text_encoding, since that is
     41          *    used to interpret the text/len parameters in draw[Pos]Text.
     42          *  - Color is always computed using the LayerInfo's fColorMode.
     43          */
     44         kEntirePaint_Bits = -1
     45 
     46     };
     47     typedef int32_t BitFlags;
     48 
     49     /**
     50      *  Info for how to apply the layer's paint and offset.
     51      *
     52      *  fColorMode controls how we compute the final color for the layer:
     53      *      The layer's paint's color is treated as the SRC
     54      *      The draw's paint's color is treated as the DST
     55      *      final-color = Mode(layers-color, draws-color);
     56      *  Any SkXfermode::Mode will work. Two common choices are:
     57      *      kSrc_Mode: to use the layer's color, ignoring the draw's
     58      *      kDst_Mode: to just keep the draw's color, ignoring the layer's
     59      */
     60     struct SK_API LayerInfo {
     61         BitFlags            fPaintBits;
     62         SkXfermode::Mode    fColorMode;
     63         SkVector            fOffset;
     64         bool                fPostTranslate; //!< applies to fOffset
     65 
     66         /**
     67          *  Initial the LayerInfo. Defaults to settings that will draw the
     68          *  layer with no changes: e.g.
     69          *      fPaintBits == 0
     70          *      fColorMode == kDst_Mode
     71          *      fOffset == (0, 0)
     72          */
     73         LayerInfo();
     74     };
     75 
     76     virtual SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE;
     77 
     78     virtual size_t contextSize() const SK_OVERRIDE { return sizeof(LayerDrawLooperContext); }
     79 
     80     virtual bool asABlurShadow(BlurShadowRec* rec) const SK_OVERRIDE;
     81 
     82     SK_TO_STRING_OVERRIDE()
     83 
     84     /// Implements Flattenable.
     85     virtual Factory getFactory() const SK_OVERRIDE { return CreateProc; }
     86     static SkFlattenable* CreateProc(SkReadBuffer& buffer);
     87 
     88 protected:
     89     SkLayerDrawLooper();
     90 
     91     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     92 
     93 private:
     94     struct Rec {
     95         Rec*    fNext;
     96         SkPaint fPaint;
     97         LayerInfo fInfo;
     98     };
     99     Rec*    fRecs;
    100     Rec*    fTopRec;
    101     int     fCount;
    102 
    103     // state-machine during the init/next cycle
    104     class LayerDrawLooperContext : public SkDrawLooper::Context {
    105     public:
    106         explicit LayerDrawLooperContext(const SkLayerDrawLooper* looper);
    107 
    108     protected:
    109         virtual bool next(SkCanvas*, SkPaint* paint) SK_OVERRIDE;
    110 
    111     private:
    112         Rec* fCurrRec;
    113 
    114         static void ApplyInfo(SkPaint* dst, const SkPaint& src, const LayerInfo&);
    115     };
    116 
    117     class MyRegistrar : public SkFlattenable::Registrar {
    118     public:
    119         MyRegistrar();
    120     };
    121 
    122     typedef SkDrawLooper INHERITED;
    123 
    124 public:
    125     class SK_API Builder {
    126     public:
    127         Builder();
    128         ~Builder();
    129 
    130         /**
    131          *  Call for each layer you want to add (from top to bottom).
    132          *  This returns a paint you can modify, but that ptr is only valid until
    133          *  the next call made to addLayer().
    134          */
    135         SkPaint* addLayer(const LayerInfo&);
    136 
    137         /**
    138          *  This layer will draw with the original paint, at the specified offset
    139          */
    140         void addLayer(SkScalar dx, SkScalar dy);
    141 
    142         /**
    143          *  This layer will with the original paint and no offset.
    144          */
    145         void addLayer() { this->addLayer(0, 0); }
    146 
    147         /// Similar to addLayer, but adds a layer to the top.
    148         SkPaint* addLayerOnTop(const LayerInfo&);
    149 
    150         /**
    151           * Pass list of layers on to newly built looper and return it. This will
    152           * also reset the builder, so it can be used to build another looper.
    153           */
    154         SkLayerDrawLooper* detachLooper();
    155 
    156     private:
    157         Rec* fRecs;
    158         Rec* fTopRec;
    159         int  fCount;
    160     };
    161 };
    162 
    163 #endif
    164