[WIP] Add Context to SkDrawLooper.

src/effects/SkLayerDrawLooper.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkCanvas.h"
 #include "SkColor.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkLayerDrawLooper.h"
 #include "SkString.h"
 #include "SkStringUtils.h"
 #include "SkUnPreMultiply.h"
 
 SkLayerDrawLooper::LayerInfo::LayerInfo() {
     fFlagsMask = 0;                     // ignore our paint flags
     fPaintBits = 0;                     // ignore our paint fields
     fColorMode = SkXfermode::kDst_Mode; // ignore our color
     fOffset.set(0, 0);
     fPostTranslate = false;
 }
 
 SkLayerDrawLooper::SkLayerDrawLooper()
         : fRecs(NULL),
           fTopRec(NULL),
-          fCount(0),
-          fCurrRec(NULL) {
+          fCount(0) {
 }
 
 SkLayerDrawLooper::~SkLayerDrawLooper() {
     Rec* rec = fRecs;
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
 }
@@ skipping 29 matching lines @@
         fRecs = rec;
     } else {
         SkASSERT(NULL != fTopRec);
         fTopRec->fNext = rec;
     }
     fTopRec = rec;
 
     return &rec->fPaint;
 }
 
-void SkLayerDrawLooper::init(SkCanvas* canvas) {
-    fCurrRec = fRecs;
+SkLayerDrawLooper::DrawContext* SkLayerDrawLooper::init(SkCanvas* canvas)
+        const {
+    SkLayerDrawLooperContext* context = new SkLayerDrawLooperContext(this);

[scroggo, 2014/02/06 17:57:13]

SkNEW_ARGS

     canvas->save(SkCanvas::kMatrix_SaveFlag);
+    return context;
 }
 
 static SkColor xferColor(SkColor src, SkColor dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kSrc_Mode:
             return src;
         case SkXfermode::kDst_Mode:
             return dst;
         default: {
             SkPMColor pmS = SkPreMultiplyColor(src);
             SkPMColor pmD = SkPreMultiplyColor(dst);
             SkPMColor result = SkXfermode::GetProc(mode)(pmS, pmD);
             return SkUnPreMultiply::PMColorToColor(result);
         }
     }
 }
 
+SkLayerDrawLooper::SkLayerDrawLooperContext::SkLayerDrawLooperContext(
+    const SkLayerDrawLooper* looper) : fCurrRec(looper->fRecs) {}
+
 // Even with kEntirePaint_Bits, we always ensure that the master paint's
 // text-encoding is respected, since that controls how we interpret the
 // text/length parameters of a draw[Pos]Text call.
 void SkLayerDrawLooper::ApplyInfo(SkPaint* dst, const SkPaint& src,
                                   const LayerInfo& info) {
 
     uint32_t mask = info.fFlagsMask;
     dst->setFlags((dst->getFlags() & ~mask) | (src.getFlags() & mask));
     dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));
 
@@ skipping 54 matching lines @@
 #endif
 }
 
 // Should we add this to canvas?
 static void postTranslate(SkCanvas* canvas, SkScalar dx, SkScalar dy) {
     SkMatrix m = canvas->getTotalMatrix();
     m.postTranslate(dx, dy);
     canvas->setMatrix(m);
 }
 
-bool SkLayerDrawLooper::next(SkCanvas* canvas, SkPaint* paint) {
+bool SkLayerDrawLooper::next_internal(SkCanvas* canvas, SkPaint* paint,
+                                      SkDrawLooper::DrawContext* context) const {
+    SkLayerDrawLooperContext* layerContext =
+        static_cast<SkLayerDrawLooperContext*>(context);
+
     canvas->restore();
-    if (NULL == fCurrRec) {
+    if (NULL == layerContext->fCurrRec) {
         return false;
     }
 
-    ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);
+    ApplyInfo(paint, layerContext->fCurrRec->fPaint,
+              layerContext->fCurrRec->fInfo);
 
     canvas->save(SkCanvas::kMatrix_SaveFlag);
-    if (fCurrRec->fInfo.fPostTranslate) {
-        postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
-                      fCurrRec->fInfo.fOffset.fY);
+    if (layerContext->fCurrRec->fInfo.fPostTranslate) {
+        postTranslate(canvas, layerContext->fCurrRec->fInfo.fOffset.fX,
+                      layerContext->fCurrRec->fInfo.fOffset.fY);
     } else {
-        canvas->translate(fCurrRec->fInfo.fOffset.fX, fCurrRec->fInfo.fOffset.fY);
+        canvas->translate(layerContext->fCurrRec->fInfo.fOffset.fX,
+                          layerContext->fCurrRec->fInfo.fOffset.fY);
     }
-    fCurrRec = fCurrRec->fNext;
+    layerContext->fCurrRec = layerContext->fCurrRec->fNext;
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
 #ifdef SK_DEBUG
@@ skipping 19 matching lines @@
         buffer.writeBool(rec->fInfo.fPostTranslate);
         buffer.writePaint(rec->fPaint);
         rec = rec->fNext;
     }
 }
 
 SkLayerDrawLooper::SkLayerDrawLooper(SkReadBuffer& buffer)
         : INHERITED(buffer),
           fRecs(NULL),
           fTopRec(NULL),
-          fCount(0),
-          fCurrRec(NULL) {
+          fCount(0) {
     int count = buffer.readInt();
 
     for (int i = 0; i < count; i++) {
         LayerInfo info;
         info.fFlagsMask = buffer.readInt();
         info.fPaintBits = buffer.readInt();
         info.fColorMode = (SkXfermode::Mode)buffer.readInt();
         buffer.readPoint(&info.fOffset);
         info.fPostTranslate = buffer.readBool();
         buffer.readPaint(this->addLayerOnTop(info));
@@ skipping 100 matching lines @@
             str->append("true ");
         } else {
             str->append("false ");
         }
 
         rec->fPaint.toString(str);
         rec = rec->fNext;
     }
 }
 #endif