skia DrawLooper

本次学习drawLooper.cpp中有关SkDrawLooper类的用法，并且分析了canvas draw api中的二层循环的作用。

SkDrawLooper有两个子类：SkLayerDrawLooper和SkBlurDrawLooper。

先看一下drawLooper.cpp里面的例子，主要看onDraw()做什么：

virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
this->init();//初始化

SkPaint  paint;
paint.setAntiAlias(true);//设置抗锯齿
paint.setTextSize(SkIntToScalar(72));//文字大小
paint.setLooper(fLooper);//设置SkDrawLooper

canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
SkIntToScalar(30), paint);//画圆
canvas->drawRectCoords(SkIntToScalar(150), SkIntToScalar(50),
SkIntToScalar(200), SkIntToScalar(100), paint);//画矩形

canvas->drawText("Looper", 6, SkIntToScalar(230), SkIntToScalar(100),
paint);//画文字
}

在onDraw()可以看到，这个函数在固定位置绘制了一个圆、一个矩形和一个“looper”文字。而在最终跑出的结果中可以看到，绘制的这三个图形都有一个模糊阴影，并且三个图形的边缘为红白相间，中间为蓝色填充。



造成这样结果的始作俑者是init()函数：

void init() {
if (fLooper) return;

static const struct {              //匿名结构体定义了一组描述参数
SkColor         fColor;        //颜色
SkPaint::Style  fStyle;        //path style
SkScalar        fWidth;        //线宽
SkScalar        fOffset;       //blur偏移
SkScalar        fBlur;         //blur sigma输入参数
} gParams[] = {                    //gParams定义了4组不同效果
{ SK_ColorWHITE, SkPaint::kStroke_Style, SkIntToScalar(1)*3/4, 0, 0 },
{ SK_ColorRED, SkPaint::kStroke_Style, SkIntToScalar(4), 0, 0 },
{ SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0 },
{ 0x88000000, SkPaint::kFill_Style, 0, SkIntToScalar(10), SkIntToScalar(3) }
};

SkLayerDrawLooper::Builder looperBuilder;//SkLayerDrawLooper的内部类

SkLayerDrawLooper::LayerInfo info;
info.fPaintBits = SkLayerDrawLooper::kStyle_Bit | SkLayerDrawLooper::kMaskFilter_Bit;
info.fColorMode = SkXfermode::kSrc_Mode;

for (size_t i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
info.fOffset.set(gParams[i].fOffset, gParams[i].fOffset);
SkPaint* paint = looperBuilder.addLayer(info);
paint->setColor(gParams[i].fColor);
paint->setStyle(gParams[i].fStyle);
paint->setStrokeWidth(gParams[i].fWidth);
if (gParams[i].fBlur > 0) {
SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(gParams[i].fBlur));
paint->setMaskFilter(mf)->unref();
}
}
fLooper = looperBuilder.detachLooper();
}

看一下init()函数中的两个类：SkLayerDrawLooper::LayerInfo和SkLayerDrawLooper::Builder。

对于SkLayerDrawLooper::LayerInfo，skia的描述如下：

/**
*  Info for how to apply the layer's paint and offset.
*
*  fColorMode controls how we compute the final color for the layer:
*      The layer's paint's color is treated as the SRC
*      The draw's paint's color is treated as the DST
*      final-color = Mode(layers-color, draws-color);
*  Any SkXfermode::Mode will work. Two common choices are:
*      kSrc_Mode: to use the layer's color, ignoring the draw's
*      kDst_Mode: to just keep the draw's color, ignoring the layer's
*/
struct SK_API LayerInfo {
BitFlags            fPaintBits;
SkXfermode::Mode    fColorMode;
SkVector            fOffset;
bool                fPostTranslate; //!< applies to fOffset

/**
*  Initial the LayerInfo. Defaults to settings that will draw the
*  layer with no changes: e.g.
*      fPaintBits == 0
*      fColorMode == kDst_Mode
*      fOffset == (0, 0)
*/
LayerInfo();
};

init()函数中定义了info的fPaintBits、fColorMode和fOffset。

再来看SkLayerDrawLooper::Builder：

class SK_API Builder {
public:
Builder();
~Builder();

/**
*  Call for each layer you want to add (from top to bottom).
*  This returns a paint you can modify, but that ptr is only valid until
*  the next call made to addLayer().
*/
SkPaint* addLayer(const LayerInfo&);

/**
*  This layer will draw with the original paint, at the specified offset
*/
void addLayer(SkScalar dx, SkScalar dy);

/**
*  This layer will with the original paint and no offset.
*/
void addLayer() { this->addLayer(0, 0); }

/// Similar to addLayer, but adds a layer to the top.
SkPaint* addLayerOnTop(const LayerInfo&);

/**
* Pass list of layers on to newly built looper and return it. This will
* also reset the builder, so it can be used to build another looper.
*/
SkLayerDrawLooper* detachLooper();

private:
Rec* fRecs;
Rec* fTopRec;
int  fCount;
};

在init()函数中，SkLayerDrawLooper::Builder的对象loopbuilder调用了addLayer()方法。

SkPaint* SkLayerDrawLooper::Builder::addLayer(const LayerInfo& info) {
fCount += 1;

Rec* rec = SkNEW(Rec);
rec->fNext = fRecs;
rec->fInfo = info;
fRecs = rec;
if (NULL == fTopRec) {
fTopRec = rec;
}

return &rec->fPaint;
}

struct Rec {
Rec*    fNext;
SkPaint fPaint;
LayerInfo fInfo;
};

addLayer()函数首先创建一个Rec结构单链表节点，然后把不同的layerInfo插入到该节点中，最后返回该节点中的fPaint。可以看到init()函数中的for循环里会设置这个fPaint的color、style、StrokeWidth和MaskFilter。设置完后loopBuilder使用detachLooper()方法把构造的SkLayerDrawLooper对象交给fLooper成员。
到这里，fLooper中保存了四种不同的paint，因此在onDraw()中调用各种draw api时产生了四种不同图形叠加到一起的效果。

但，在draw api中是draw looper是怎样工作的呢？

可以拿onDraw()中的drawCircle()作为切入点，看一下draw looper的到底是怎样工作的。

void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius,
const SkPaint& paint) {
if (radius < 0) {
radius = 0;
}

SkRect  r;
r.set(cx - radius, cy - radius, cx + radius, cy + radius);
this->drawOval(r, paint);
}

void SkCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
SkRect storage;
const SkRect* bounds = NULL;
if (paint.canComputeFastBounds()) { //判断是否可以快速计算绘制边界（主要判断当前paint和skdrawlooper中的paint是否有mask）
bounds = &paint.computeFastBounds(oval, &storage);
if (this->quickReject(*bounds)) {
return;
}
}

LOOPER_BEGIN(paint, SkDrawFilter::kOval_Type, bounds)

while (iter.next()) {
iter.fDevice->drawOval(iter, oval, looper.paint());
}

LOOPER_END
}

从上面的代码中可以看出，drawCircle()实际就是drawOval()，通过找出外切矩形来确定圆形的位置和形状。

drawOval()函数可以看出做了三件事情：

1.计算绘制边界；

2.外层循环AutoDrawLooper；

3.内层循环DrawIter。

在第一点中，由于drawOval()的参数中已经有了一个skrect，这可以看做一个初始的绘制边界，之后这个初始边界会被SkDrawLooper中所保存的paint去计算一些变换（比如maskfilter、patheffect），这些变换可能会改变最终的一个绘制边界。如果绘制边界为空，或者为无限，那就拒绝绘制。

第二点，从代码中看LOOPER_BEGIN是一个宏定义，宏展开代码如下：

#define LOOPER_BEGIN(paint, type, bounds)                           \
this->predrawNotify();                                          \
AutoDrawLooper  looper(this, paint, false, bounds);             \
while (looper.next(type)) {                                     \
SkAutoBounderCommit ac(fBounder);                           \
SkDrawIter          iter(this);

#define LOOPER_END    }

宏展开后就可以很清楚的看到第一层循环，该循环的判断条件是AutoDrawLooper对象，先看一下这个类的构造函数：

AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint,
bool skipLayerForImageFilter = false,
const SkRect* bounds = NULL) : fOrigPaint(paint) {
fCanvas = canvas;
fFilter = canvas->getDrawFilter();
fPaint = NULL;
fSaveCount = canvas->getSaveCount();
fDoClearImageFilter = false;
fDone = false;

if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
SkPaint tmp;
tmp.setImageFilter(fOrigPaint.getImageFilter());
(void)canvas->internalSaveLayer(bounds, &tmp, SkCanvas::kARGB_ClipLayer_SaveFlag,
true, SkCanvas::kFullLayer_SaveLayerStrategy);
// we'll clear the imageFilter for the actual draws in next(), so
// it will only be applied during the restore().
fDoClearImageFilter = true;
}

if (SkDrawLooper* looper = paint.getLooper()) {
void* buffer = fLooperContextAllocator.reserveT<SkDrawLooper::Context>(
looper->contextSize());
fLooperContext = looper->createContext(canvas, buffer);
fIsSimple = false;
} else {
fLooperContext = NULL;
// can we be marked as simple?
fIsSimple = !fFilter && !fDoClearImageFilter;
}
}

在构造函数中可以直接去看第二个if语句，这个语句里所做的事情是：如果paint设置了SkDrawLooper对象，则会在给定的一块buffer创建一个context。如果paint设置的DrawLooper对象是SkLayerDrawLooper对象，则创建的context实际是LayerDrawLooperContext。在构造LayerDrawLooperContext时，它的成员是一个Rec结构指针fCurrRec，fCurrRec会指向paint中的SkLayerDrawLooper对象中的Rec结构链表头。

我们再来看一下SkLayerDrawLooper中Rec这个结构体：（对于SkDrawLooper另一个子类暂时不分析）

    struct Rec {
Rec*    fNext;
SkPaint fPaint;
LayerInfo fInfo;
};

Rec链表节点保存着一个layerinfo和一个paint，其中layerinfo结构如下：

/**
*  Info for how to apply the layer's paint and offset.
*
*  fColorMode controls how we compute the final color for the layer:
*      The layer's paint's color is treated as the SRC
*      The draw's paint's color is treated as the DST
*      final-color = Mode(layers-color, draws-color);
*  Any SkXfermode::Mode will work. Two common choices are:
*      kSrc_Mode: to use the layer's color, ignoring the draw's
*      kDst_Mode: to just keep the draw's color, ignoring the layer's
*/
struct SK_API LayerInfo {
BitFlags            fPaintBits;
SkXfermode::Mode    fColorMode;
SkVector            fOffset;
bool                fPostTranslate; //!< applies to fOffset

对于layerinfo成员fColorMode的解释是：这个成员用来计算当前layer（这个layer指的的是效果层）的最终颜色，如果这个成员值为kSrc_Mode，则使用当前layer's paint的颜色，且忽略要绘制layer's paint的颜色；如果值为kDst_Mode，行为相反。

对于成员fPaintBits，它的有关解释在以下枚举结构中：

/**
*  Bits specifies which aspects of the layer's paint should replace the
*  corresponding aspects on the draw's paint.
*  kEntirePaint_Bits means use the layer's paint completely.
*  0 means ignore the layer's paint... except for fColorMode, which is
*  always applied.
*/
enum Bits {
kStyle_Bit      = 1 << 0,   //!< use this layer's Style/stroke settings
kTextSkewX_Bit  = 1 << 1,   //!< use this layer's textskewx
kPathEffect_Bit = 1 << 2,   //!< use this layer's patheffect
kMaskFilter_Bit = 1 << 3,   //!< use this layer's maskfilter
kShader_Bit     = 1 << 4,   //!< use this layer's shader
kColorFilter_Bit = 1 << 5,  //!< use this layer's colorfilter
kXfermode_Bit   = 1 << 6,   //!< use this layer's xfermode

/**
*  Use the layer's paint entirely, with these exceptions:
*  - We never override the draw's paint's text_encoding, since that is
*    used to interpret the text/len parameters in draw[Pos]Text.
*  - Color is always computed using the LayerInfo's fColorMode.
*/
kEntirePaint_Bits = -1

};

fPaintBits用来判断使用当前layer的Style/patheffect/maskfilter/shader/colorfilter/xfermode，还是使用即将要绘制的layer's paint。

对于成员fOffset和fPostTranslate，它们用来处理当前layer的位置偏移，会改变canvas的matrix。

因此，layerinfo保存了SkLayerDrawLooper中的每一个layer的paint mode flag和偏移信息。

然后回到之前的外层循环宏展开，构造完AutoDrawLooper对象looper，就会执行looper.next(type)。

bool next(SkDrawFilter::Type drawType) {
if (fDone) {
return false;
} else if (fIsSimple) {
fDone = true;
fPaint = &fOrigPaint;
return !fPaint->nothingToDraw();
} else {
return this->doNext(drawType);
}
}

bool AutoDrawLooper::doNext(SkDrawFilter::Type drawType) {
fPaint = NULL;
SkASSERT(!fIsSimple);
SkASSERT(fLooperContext || fFilter || fDoClearImageFilter);

SkPaint* paint = fLazyPaint.set(fOrigPaint);

if (fDoClearImageFilter) {
paint->setImageFilter(NULL);
}

if (fLooperContext && !fLooperContext->next(fCanvas, paint)) {
fDone = true;
return false;
}
if (fFilter) {
if (!fFilter->filter(paint, drawType)) {
fDone = true;
return false;
}
if (NULL == fLooperContext) {
// no looper means we only draw once
fDone = true;
}
}
fPaint = paint;

// if we only came in here for the imagefilter, mark us as done
if (!fLooperContext && !fFilter) {
fDone = true;
}

// call this after any possible paint modifiers
if (fPaint->nothingToDraw()) {
fPaint = NULL;
return false;
}
return true;
}

考虑looper.next(type)执行到AutoDrawLooper::doNext()的情况，在doNext()第二个if语句中，会去执行fLooperContext->next(fCanvas, paint)，这里执行的就是刚刚构造的LayerDrawLooperContext对象中的next()方法：

bool SkLayerDrawLooper::LayerDrawLooperContext::next(SkCanvas* canvas,
SkPaint* paint) {
canvas->restore();
if (NULL == fCurrRec) {
return false;
}

ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);

canvas->save();
if (fCurrRec->fInfo.fPostTranslate) {
postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
fCurrRec->fInfo.fOffset.fY);
} else {
canvas->translate(fCurrRec->fInfo.fOffset.fX,
fCurrRec->fInfo.fOffset.fY);
}
fCurrRec = fCurrRec->fNext;

return true;
}

看到这里就比较明显了，我们在drawLooper.cpp中的init()函数中定义的四种效果会在这里进行处理。首先是在ApplyInfo()中处理我们定义的color、style、width和maskfilter；然后处理offset；最后fCurrRec指向下一个Rec节点。如果到了Rec链表尾，则外层循环结束。看一下ApplyInfo()设置的info的过程：

void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo(
SkPaint* dst, const SkPaint& src, const LayerInfo& info) {

dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));

BitFlags bits = info.fPaintBits;
SkPaint::TextEncoding encoding = dst->getTextEncoding();

if (0 == bits) {
return;
}
if (kEntirePaint_Bits == bits) {
// we've already computed these, so save it from the assignment
uint32_t f = dst->getFlags();
SkColor c = dst->getColor();
*dst = src;
dst->setFlags(f);
dst->setColor(c);
dst->setTextEncoding(encoding);
return;
}

if (bits & kStyle_Bit) {
dst->setStyle(src.getStyle());
dst->setStrokeWidth(src.getStrokeWidth());
dst->setStrokeMiter(src.getStrokeMiter());
dst->setStrokeCap(src.getStrokeCap());
dst->setStrokeJoin(src.getStrokeJoin());
}

if (bits & kTextSkewX_Bit) {
dst->setTextSkewX(src.getTextSkewX());
}

if (bits & kPathEffect_Bit) {
dst->setPathEffect(src.getPathEffect());
}
if (bits & kMaskFilter_Bit) {
dst->setMaskFilter(src.getMaskFilter());
}
if (bits & kShader_Bit) {
dst->setShader(src.getShader());
}
if (bits & kColorFilter_Bit) {
dst->setColorFilter(src.getColorFilter());
}
if (bits & kXfermode_Bit) {
dst->setXfermode(src.getXfermode());
}

// we don't override these
#if 0
dst->setTypeface(src.getTypeface());
dst->setTextSize(src.getTextSize());
dst->setTextScaleX(src.getTextScaleX());
dst->setRasterizer(src.getRasterizer());
dst->setLooper(src.getLooper());
dst->setTextEncoding(src.getTextEncoding());
dst->setHinting(src.getHinting());
#endif
}

对于这行：dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));

dst指的是draw api中的paint（跟着函数调用一层层传下来），也就是即将要绘制的layer's paint ；src指的是SkLayerDrawLooper中Rec结构成员中的paint。dst设置当前paint的颜色时是根据layerinfo成员fColorMode决定的（如上面layerinfo中的注释）。

我们回到DrawLooper这个例子，只拿绘制的圆形来说明：gParams数组定义的每组效果的颜色依次是白色，红色，蓝色，灰色；绘制圆形时先绘制白色的圆环（style=stroke），然后时红色的圆环(style=stroke)，之后是蓝色的圆盘(style=full)，最后是灰色的圆盘(style=full)，这里每次绘制都是绘制到一个layer上；由于每组效果的layerinfo成员fColorMode都设置的是kSrc_mode，因此这些layer上的图案混合在一起的时候，在相互重叠的地方都保持的是绘制时当前layer的颜色。直观的效果看上去就是后面绘制的图案被之前的layer的图案挡住，白色圆环盖在了红色圆环上，蓝色圆盘的边缘被上面两层图案盖住，灰色圆盘被之前三层的图案盖住。

下面我们再看内存循环，先看SkDrawIter的构造函数：

SkDrawIter(SkCanvas* canvas, bool skipEmptyClips = true) {
canvas = canvas->canvasForDrawIter();
fCanvas = canvas;
canvas->updateDeviceCMCache();

fClipStack = &canvas->fClipStack;
fBounder = canvas->getBounder();
fCurrLayer = canvas->fMCRec->fTopLayer;
fSkipEmptyClips = skipEmptyClips;
}

对于SkDrawIter类，它的基类是SkDraw；它的会在构造函数中为每一层layer（这个layer指的是图层）更新相对应的MCRec状态（图层链表DeviceCM中每一个layer与状态栈中的栈帧MCRec有着一一对应关系，但有的栈帧MCRec可能没有layer）；这是为了在正式绘制在layer上之前，调整好layer的空间关系(matrix)和剪裁区域(clip)，后面正式开始绘制的时候都按照调整好的matrix和clip去绘制。

内存循环的判断条件是iter.next()：

bool next() {
// skip over recs with empty clips
if (fSkipEmptyClips) {
while (fCurrLayer && fCurrLayer->fClip.isEmpty()) {
fCurrLayer = fCurrLayer->fNext;
}
}

const DeviceCM* rec = fCurrLayer;
if (rec && rec->fDevice) {

fMatrix = rec->fMatrix;
fClip   = &((SkRasterClip*)&rec->fClip)->forceGetBW();
fRC     = &rec->fClip;
fDevice = rec->fDevice;
fBitmap = &fDevice->accessBitmap(true);
fPaint  = rec->fPaint;
SkDEBUGCODE(this->validate();)

fCurrLayer = rec->fNext;
if (fBounder) {
fBounder->setClip(fClip);
}
// fCurrLayer may be NULL now

return true;
}
return false;
}

SkDrawIter类的next()方法的作用是：在正式绘制每一层layer之前，首先跳过clip为空的layer（即clip为空的layer不绘制）；然后把当前要绘制的layer一些有用参数传递给SkDrawIter对象的成员，这些成员都是已经更新过matrix和clip状态的，已经具备了绘制条件；最后判断是否到了图层链表尾，用于内层循环判断条件。

从代码中看出内层循环依然是对layer的MC状态一些迭代更新，并在循环体中调用实际绘制函数去绘制当前状态所依附的所有Layer，这里与SkDrawLooper没有关系。

总结：

看到这里可以对SkDrawLooper（针对子类SkLayerDrawLooper）的作用作以下总结：

1.paint可比喻为画笔，画笔可以画出各种效果；这些效果会分布在不同的效果层。SkLayerDrawLooper::LayerInfo定义效果层的paint mode flag和偏移；它决定了在绘制前使用当前效果层的paint效果还是使用即将绘制的paint效果，每一个paint对应的它对应的效果用Rec节点保存在SkLayerDrawLooper中，这个Rec结构可以认为是一个效果层。

2.SkLayerDrawLooper::Builder的对象调用addLayer()函数首先创建Rec结构单链表节点，然后把不同的layerInfo插入到该节点中，最后返回每个节点中与新添加的layerinfo对应的fPaint。有了Rec结构链表，SkLayerDrawLooper::Builder会调用detachLooper()方法返回一个SkLayerDrawLooper对象，这个SkLayerDrawLooper对象可以设置到即将绘制的paint中。这里的addLayer就是添加效果层。

3.把SkLayerDrawLooper对象设置给一个paint，当canvas调用draw api时会使用SkLayerDrawLooper对象去计算绘制边界，然后在draw api的外层循环中使用SkLayerDrawLooper::LayerDrawLooperContext::next()函数去判断使用即将绘制的paint效果还是looper中paint效果，并且会处理每一层的偏移。

对于二层循环总结如下：

1.外层循环的作用是判断使用即将绘制的paint效果还是looper中paint效果，并且会处理每一层的偏移；

2.内层循环是在正式绘制在layer（这个layer是图层）上之前，调整好layer的空间关系(matrix)和剪裁区域(clip)，然后跳过clip为空的layer，把当前要绘制的layer一些有用参数传递给SkDrawIter对象的成员，后面让SkDrawIter中的Device去调用实际的绘制函数；这个过程依次迭代。

假设SkLayerDrawLooper对象为looper，SkDrawIter对象为iter，下面这张图简单的描述了两层循环的行为，绿色虚线内为一次外层循环，红色虚线为一次内层循环。