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     SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const override;
77 
contextSize()78     size_t contextSize() const override { return sizeof(LayerDrawLooperContext); }
79 
80     bool asABlurShadow(BlurShadowRec* rec) const override;
81 
SK_TO_STRING_OVERRIDE()82     SK_TO_STRING_OVERRIDE()
83 
84     Factory getFactory() const override { return CreateProc; }
85     static SkFlattenable* CreateProc(SkReadBuffer& buffer);
86 
87 protected:
88     SkLayerDrawLooper();
89 
90     void flatten(SkWriteBuffer&) const override;
91 
92 private:
93     struct Rec {
94         Rec*    fNext;
95         SkPaint fPaint;
96         LayerInfo fInfo;
97     };
98     Rec*    fRecs;
99     Rec*    fTopRec;
100     int     fCount;
101 
102     // state-machine during the init/next cycle
103     class LayerDrawLooperContext : public SkDrawLooper::Context {
104     public:
105         explicit LayerDrawLooperContext(const SkLayerDrawLooper* looper);
106 
107     protected:
108         bool next(SkCanvas*, SkPaint* paint) override;
109 
110     private:
111         Rec* fCurrRec;
112 
113         static void ApplyInfo(SkPaint* dst, const SkPaint& src, const LayerInfo&);
114     };
115 
116     class MyRegistrar : public SkFlattenable::Registrar {
117     public:
118         MyRegistrar();
119     };
120 
121     typedef SkDrawLooper INHERITED;
122 
123 public:
124     class SK_API Builder {
125     public:
126         Builder();
127         ~Builder();
128 
129         /**
130          *  Call for each layer you want to add (from top to bottom).
131          *  This returns a paint you can modify, but that ptr is only valid until
132          *  the next call made to addLayer().
133          */
134         SkPaint* addLayer(const LayerInfo&);
135 
136         /**
137          *  This layer will draw with the original paint, at the specified offset
138          */
139         void addLayer(SkScalar dx, SkScalar dy);
140 
141         /**
142          *  This layer will with the original paint and no offset.
143          */
addLayer()144         void addLayer() { this->addLayer(0, 0); }
145 
146         /// Similar to addLayer, but adds a layer to the top.
147         SkPaint* addLayerOnTop(const LayerInfo&);
148 
149         /**
150           * Pass list of layers on to newly built looper and return it. This will
151           * also reset the builder, so it can be used to build another looper.
152           */
153         SkLayerDrawLooper* detachLooper();
154 
155     private:
156         Rec* fRecs;
157         Rec* fTopRec;
158         int  fCount;
159     };
160 };
161 
162 #endif
163