src/third_party/skia/src/effects/SkLayerDrawLooper.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   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 #include "SkCanvas.h"
   9 #include "SkColor.h"
  10 #include "SkReadBuffer.h"
  11 #include "SkWriteBuffer.h"
  12 #include "SkLayerDrawLooper.h"
  13 #include "SkString.h"
  14 #include "SkStringUtils.h"
  15 #include "SkUnPreMultiply.h"
  16
  17 SkLayerDrawLooper::LayerInfo::LayerInfo() {
  18     fPaintBits = 0;                     // ignore our paint fields
  19     fColorMode = SkXfermode::kDst_Mode; // ignore our color
  20     fOffset.set(0, 0);
  21     fPostTranslate = false;
  22 }
  23
  24 SkLayerDrawLooper::SkLayerDrawLooper()
  25         : fRecs(NULL),
  26           fTopRec(NULL),
  27           fCount(0) {
  28 }
  29
  30 SkLayerDrawLooper::~SkLayerDrawLooper() {
  31     Rec* rec = fRecs;
  32     while (rec) {
  33         Rec* next = rec->fNext;
  34         SkDELETE(rec);
  35         rec = next;
  36     }
  37 }
  38
  39 SkLayerDrawLooper::Context* SkLayerDrawLooper::createContext(SkCanvas* canvas, void* storage) const {
  40     canvas->save();
  41     return SkNEW_PLACEMENT_ARGS(storage, LayerDrawLooperContext, (this));
  42 }
  43
  44 static SkColor xferColor(SkColor src, SkColor dst, SkXfermode::Mode mode) {
  45     switch (mode) {
  46         case SkXfermode::kSrc_Mode:
  47             return src;
  48         case SkXfermode::kDst_Mode:
  49             return dst;
  50         default: {
  51             SkPMColor pmS = SkPreMultiplyColor(src);
  52             SkPMColor pmD = SkPreMultiplyColor(dst);
  53             SkPMColor result = SkXfermode::GetProc(mode)(pmS, pmD);
  54             return SkUnPreMultiply::PMColorToColor(result);
  55         }
  56     }
  57 }
  58
  59 // Even with kEntirePaint_Bits, we always ensure that the master paint's
  60 // text-encoding is respected, since that controls how we interpret the
  61 // text/length parameters of a draw[Pos]Text call.
  62 void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo(
  63         SkPaint* dst, const SkPaint& src, const LayerInfo& info) {
  64
  65     dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));
  66
  67     BitFlags bits = info.fPaintBits;
  68     SkPaint::TextEncoding encoding = dst->getTextEncoding();
  69
  70     if (0 == bits) {
  71         return;
  72     }
  73     if (kEntirePaint_Bits == bits) {
  74         // we've already computed these, so save it from the assignment
  75         uint32_t f = dst->getFlags();
  76         SkColor c = dst->getColor();
  77         *dst = src;
  78         dst->setFlags(f);
  79         dst->setColor(c);
  80         dst->setTextEncoding(encoding);
  81         return;
  82     }
  83
  84     if (bits & kStyle_Bit) {
  85         dst->setStyle(src.getStyle());
  86         dst->setStrokeWidth(src.getStrokeWidth());
  87         dst->setStrokeMiter(src.getStrokeMiter());
  88         dst->setStrokeCap(src.getStrokeCap());
  89         dst->setStrokeJoin(src.getStrokeJoin());
  90     }
  91
  92     if (bits & kTextSkewX_Bit) {
  93         dst->setTextSkewX(src.getTextSkewX());
  94     }
  95
  96     if (bits & kPathEffect_Bit) {
  97         dst->setPathEffect(src.getPathEffect());
  98     }
  99     if (bits & kMaskFilter_Bit) {
 100         dst->setMaskFilter(src.getMaskFilter());
 101     }
 102     if (bits & kShader_Bit) {
 103         dst->setShader(src.getShader());
 104     }
 105     if (bits & kColorFilter_Bit) {
 106         dst->setColorFilter(src.getColorFilter());
 107     }
 108     if (bits & kXfermode_Bit) {
 109         dst->setXfermode(src.getXfermode());
 110     }
 111
 112     // we don't override these
 113 #if 0
 114     dst->setTypeface(src.getTypeface());
 115     dst->setTextSize(src.getTextSize());
 116     dst->setTextScaleX(src.getTextScaleX());
 117     dst->setRasterizer(src.getRasterizer());
 118     dst->setLooper(src.getLooper());
 119     dst->setTextEncoding(src.getTextEncoding());
 120     dst->setHinting(src.getHinting());
 121 #endif
 122 }
 123
 124 // Should we add this to canvas?
 125 static void postTranslate(SkCanvas* canvas, SkScalar dx, SkScalar dy) {
 126     SkMatrix m = canvas->getTotalMatrix();
 127     m.postTranslate(dx, dy);
 128     canvas->setMatrix(m);
 129 }
 130
 131 SkLayerDrawLooper::LayerDrawLooperContext::LayerDrawLooperContext(
 132         const SkLayerDrawLooper* looper) : fCurrRec(looper->fRecs) {}
 133
 134 bool SkLayerDrawLooper::LayerDrawLooperContext::next(SkCanvas* canvas,
 135                                                      SkPaint* paint) {
 136     canvas->restore();
 137     if (NULL == fCurrRec) {
 138         return false;
 139     }
 140
 141     ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);
 142
 143     canvas->save();
 144     if (fCurrRec->fInfo.fPostTranslate) {
 145         postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
 146                       fCurrRec->fInfo.fOffset.fY);
 147     } else {
 148         canvas->translate(fCurrRec->fInfo.fOffset.fX,
 149                           fCurrRec->fInfo.fOffset.fY);
 150     }
 151     fCurrRec = fCurrRec->fNext;
 152
 153     return true;
 154 }
 155
 156 bool SkLayerDrawLooper::asABlurShadow(BlurShadowRec* bsRec) const {
 157     if (fCount != 2) {
 158         return false;
 159     }
 160     const Rec* rec = fRecs;
 161
 162     // bottom layer needs to be just blur(maskfilter)
 163     if ((rec->fInfo.fPaintBits & ~kMaskFilter_Bit)) {
 164         return false;
 165     }
 166     if (SkXfermode::kSrc_Mode != rec->fInfo.fColorMode) {
 167         return false;
 168     }
 169     const SkMaskFilter* mf = rec->fPaint.getMaskFilter();
 170     if (NULL == mf) {
 171         return false;
 172     }
 173     SkMaskFilter::BlurRec maskBlur;
 174     if (!mf->asABlur(&maskBlur)) {
 175         return false;
 176     }
 177
 178     rec = rec->fNext;
 179     // top layer needs to be "plain"
 180     if (rec->fInfo.fPaintBits) {
 181         return false;
 182     }
 183     if (SkXfermode::kDst_Mode != rec->fInfo.fColorMode) {
 184         return false;
 185     }
 186     if (!rec->fInfo.fOffset.equals(0, 0)) {
 187         return false;
 188     }
 189
 190     if (bsRec) {
 191         bsRec->fSigma = maskBlur.fSigma;
 192         bsRec->fOffset = fRecs->fInfo.fOffset;
 193         bsRec->fColor = fRecs->fPaint.getColor();
 194         bsRec->fStyle = maskBlur.fStyle;
 195         bsRec->fQuality = maskBlur.fQuality;
 196     }
 197     return true;
 198 }
 199
 200 ///////////////////////////////////////////////////////////////////////////////
 201
 202 void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
 203     this->INHERITED::flatten(buffer);
 204
 205 #ifdef SK_DEBUG
 206     {
 207         Rec* rec = fRecs;
 208         int count = 0;
 209         while (rec) {
 210             rec = rec->fNext;
 211             count += 1;
 212         }
 213         SkASSERT(count == fCount);
 214     }
 215 #endif
 216
 217     buffer.writeInt(fCount);
 218
 219     Rec* rec = fRecs;
 220     for (int i = 0; i < fCount; i++) {
 221         // Legacy "flagsmask" field -- now ignored, remove when we bump version
 222         buffer.writeInt(0);
 223
 224         buffer.writeInt(rec->fInfo.fPaintBits);
 225         buffer.writeInt(rec->fInfo.fColorMode);
 226         buffer.writePoint(rec->fInfo.fOffset);
 227         buffer.writeBool(rec->fInfo.fPostTranslate);
 228         buffer.writePaint(rec->fPaint);
 229         rec = rec->fNext;
 230     }
 231 }
 232
 233 SkFlattenable* SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
 234     int count = buffer.readInt();
 235
 236     Builder builder;
 237     for (int i = 0; i < count; i++) {
 238         LayerInfo info;
 239         // Legacy "flagsmask" field -- now ignored, remove when we bump version
 240         (void)buffer.readInt();
 241
 242         info.fPaintBits = buffer.readInt();
 243         info.fColorMode = (SkXfermode::Mode)buffer.readInt();
 244         buffer.readPoint(&info.fOffset);
 245         info.fPostTranslate = buffer.readBool();
 246         buffer.readPaint(builder.addLayerOnTop(info));
 247     }
 248     SkLayerDrawLooper* looper = builder.detachLooper();
 249     SkASSERT(count == looper->fCount);
 250
 251 #ifdef SK_DEBUG
 252     {
 253         Rec* rec = looper->fRecs;
 254         int n = 0;
 255         while (rec) {
 256             rec = rec->fNext;
 257             n += 1;
 258         }
 259         SkASSERT(count == n);
 260     }
 261 #endif
 262
 263     return looper;
 264 }
 265
 266 #ifndef SK_IGNORE_TO_STRING
 267 void SkLayerDrawLooper::toString(SkString* str) const {
 268     str->appendf("SkLayerDrawLooper (%d): ", fCount);
 269
 270     Rec* rec = fRecs;
 271     for (int i = 0; i < fCount; i++) {
 272         str->appendf("%d: paintBits: (", i);
 273         if (0 == rec->fInfo.fPaintBits) {
 274             str->append("None");
 275         } else if (kEntirePaint_Bits == rec->fInfo.fPaintBits) {
 276             str->append("EntirePaint");
 277         } else {
 278             bool needSeparator = false;
 279             SkAddFlagToString(str, SkToBool(kStyle_Bit & rec->fInfo.fPaintBits), "Style",
 280                               &needSeparator);
 281             SkAddFlagToString(str, SkToBool(kTextSkewX_Bit & rec->fInfo.fPaintBits), "TextSkewX",
 282                               &needSeparator);
 283             SkAddFlagToString(str, SkToBool(kPathEffect_Bit & rec->fInfo.fPaintBits), "PathEffect",
 284                               &needSeparator);
 285             SkAddFlagToString(str, SkToBool(kMaskFilter_Bit & rec->fInfo.fPaintBits), "MaskFilter",
 286                               &needSeparator);
 287             SkAddFlagToString(str, SkToBool(kShader_Bit & rec->fInfo.fPaintBits), "Shader",
 288                               &needSeparator);
 289             SkAddFlagToString(str, SkToBool(kColorFilter_Bit & rec->fInfo.fPaintBits), "ColorFilter",
 290                               &needSeparator);
 291             SkAddFlagToString(str, SkToBool(kXfermode_Bit & rec->fInfo.fPaintBits), "Xfermode",
 292                               &needSeparator);
 293         }
 294         str->append(") ");
 295
 296         static const char* gModeStrings[SkXfermode::kLastMode+1] = {
 297             "kClear", "kSrc", "kDst", "kSrcOver", "kDstOver", "kSrcIn", "kDstIn",
 298             "kSrcOut", "kDstOut", "kSrcATop", "kDstATop", "kXor", "kPlus",
 299             "kMultiply", "kScreen", "kOverlay", "kDarken", "kLighten", "kColorDodge",
 300             "kColorBurn", "kHardLight", "kSoftLight", "kDifference", "kExclusion"
 301         };
 302
 303         str->appendf("mode: %s ", gModeStrings[rec->fInfo.fColorMode]);
 304
 305         str->append("offset: (");
 306         str->appendScalar(rec->fInfo.fOffset.fX);
 307         str->append(", ");
 308         str->appendScalar(rec->fInfo.fOffset.fY);
 309         str->append(") ");
 310
 311         str->append("postTranslate: ");
 312         if (rec->fInfo.fPostTranslate) {
 313             str->append("true ");
 314         } else {
 315             str->append("false ");
 316         }
 317
 318         rec->fPaint.toString(str);
 319         rec = rec->fNext;
 320     }
 321 }
 322 #endif
 323
 324 SkLayerDrawLooper::Builder::Builder()
 325         : fRecs(NULL),
 326           fTopRec(NULL),
 327           fCount(0) {
 328 }
 329
 330 SkLayerDrawLooper::Builder::~Builder() {
 331     Rec* rec = fRecs;
 332     while (rec) {
 333         Rec* next = rec->fNext;
 334         SkDELETE(rec);
 335         rec = next;
 336     }
 337 }
 338
 339 SkPaint* SkLayerDrawLooper::Builder::addLayer(const LayerInfo& info) {
 340     fCount += 1;
 341
 342     Rec* rec = SkNEW(Rec);
 343     rec->fNext = fRecs;
 344     rec->fInfo = info;
 345     fRecs = rec;
 346     if (NULL == fTopRec) {
 347         fTopRec = rec;
 348     }
 349
 350     return &rec->fPaint;
 351 }
 352
 353 void SkLayerDrawLooper::Builder::addLayer(SkScalar dx, SkScalar dy) {
 354     LayerInfo info;
 355
 356     info.fOffset.set(dx, dy);
 357     (void)this->addLayer(info);
 358 }
 359
 360 SkPaint* SkLayerDrawLooper::Builder::addLayerOnTop(const LayerInfo& info) {
 361     fCount += 1;
 362
 363     Rec* rec = SkNEW(Rec);
 364     rec->fNext = NULL;
 365     rec->fInfo = info;
 366     if (NULL == fRecs) {
 367         fRecs = rec;
 368     } else {
 369         SkASSERT(NULL != fTopRec);
 370         fTopRec->fNext = rec;
 371     }
 372     fTopRec = rec;
 373
 374     return &rec->fPaint;
 375 }
 376
 377 SkLayerDrawLooper* SkLayerDrawLooper::Builder::detachLooper() {
 378     SkLayerDrawLooper* looper = SkNEW(SkLayerDrawLooper);
 379     looper->fCount = fCount;
 380     looper->fRecs = fRecs;
 381
 382     fCount = 0;
 383     fRecs = NULL;
 384     fTopRec = NULL;
 385
 386     return looper;
 387 }