src/third_party/skia/src/effects/SkLayerRasterizer.cpp

   1
   2 /*
   3  * Copyright 2006 The Android Open Source Project
   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
   9
  10 #include "SkLayerRasterizer.h"
  11 #include "SkDraw.h"
  12 #include "SkReadBuffer.h"
  13 #include "SkWriteBuffer.h"
  14 #include "SkMask.h"
  15 #include "SkMaskFilter.h"
  16 #include "SkPaint.h"
  17 #include "SkPath.h"
  18 #include "SkPathEffect.h"
  19 #include "../core/SkRasterClip.h"
  20 #include "SkXfermode.h"
  21 #include <new>
  22
  23 struct SkLayerRasterizer_Rec {
  24     SkPaint     fPaint;
  25     SkVector    fOffset;
  26 };
  27
  28 SkLayerRasterizer::SkLayerRasterizer()
  29     : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
  30 {
  31 }
  32
  33 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers)
  34 {
  35 }
  36
  37 // Helper function to call destructors on SkPaints held by layers and delete layers.
  38 static void clean_up_layers(SkDeque* layers) {
  39     SkDeque::F2BIter        iter(*layers);
  40     SkLayerRasterizer_Rec*  rec;
  41
  42     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
  43         rec->fPaint.~SkPaint();
  44
  45     SkDELETE(layers);
  46 }
  47
  48 SkLayerRasterizer::~SkLayerRasterizer() {
  49     SkASSERT(fLayers);
  50     clean_up_layers(const_cast<SkDeque*>(fLayers));
  51 }
  52
  53 static bool compute_bounds(const SkDeque& layers, const SkPath& path,
  54                            const SkMatrix& matrix,
  55                            const SkIRect* clipBounds, SkIRect* bounds) {
  56     SkDeque::F2BIter        iter(layers);
  57     SkLayerRasterizer_Rec*  rec;
  58
  59     bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
  60
  61     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
  62         const SkPaint&  paint = rec->fPaint;
  63         SkPath          fillPath, devPath;
  64         const SkPath*   p = &path;
  65
  66         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
  67             paint.getFillPath(path, &fillPath);
  68             p = &fillPath;
  69         }
  70         if (p->isEmpty()) {
  71             continue;
  72         }
  73
  74         // apply the matrix and offset
  75         {
  76             SkMatrix m = matrix;
  77             m.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
  78             p->transform(m, &devPath);
  79         }
  80
  81         SkMask  mask;
  82         if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(),
  83                                 &matrix, &mask,
  84                                 SkMask::kJustComputeBounds_CreateMode,
  85                                 SkPaint::kFill_Style)) {
  86             return false;
  87         }
  88
  89         bounds->join(mask.fBounds);
  90     }
  91     return true;
  92 }
  93
  94 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
  95                                     const SkIRect* clipBounds,
  96                                     SkMask* mask, SkMask::CreateMode mode) const {
  97     SkASSERT(fLayers);
  98     if (fLayers->empty()) {
  99         return false;
 100     }
 101
 102     if (SkMask::kJustRenderImage_CreateMode != mode) {
 103         if (!compute_bounds(*fLayers, path, matrix, clipBounds, &mask->fBounds))
 104             return false;
 105     }
 106
 107     if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
 108         mask->fFormat   = SkMask::kA8_Format;
 109         mask->fRowBytes = mask->fBounds.width();
 110         size_t size = mask->computeImageSize();
 111         if (0 == size) {
 112             return false;   // too big to allocate, abort
 113         }
 114         mask->fImage = SkMask::AllocImage(size);
 115         memset(mask->fImage, 0, size);
 116     }
 117
 118     if (SkMask::kJustComputeBounds_CreateMode != mode) {
 119         SkBitmap        device;
 120         SkRasterClip    rectClip;
 121         SkDraw          draw;
 122         SkMatrix        translatedMatrix;  // this translates us to our local pixels
 123         SkMatrix        drawMatrix;        // this translates the path by each layer's offset
 124
 125         rectClip.setRect(SkIRect::MakeWH(mask->fBounds.width(), mask->fBounds.height()));
 126
 127         translatedMatrix = matrix;
 128         translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
 129                                        -SkIntToScalar(mask->fBounds.fTop));
 130
 131         device.installMaskPixels(*mask);
 132
 133         draw.fBitmap    = &device;
 134         draw.fMatrix    = &drawMatrix;
 135         draw.fRC        = &rectClip;
 136         draw.fClip      = &rectClip.bwRgn();
 137         // we set the matrixproc in the loop, as the matrix changes each time (potentially)
 138
 139         SkDeque::F2BIter        iter(*fLayers);
 140         SkLayerRasterizer_Rec*  rec;
 141
 142         while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
 143             drawMatrix = translatedMatrix;
 144             drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
 145             draw.drawPath(path, rec->fPaint);
 146         }
 147     }
 148     return true;
 149 }
 150
 151 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
 152 SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer)
 153     : SkRasterizer(buffer), fLayers(ReadLayers(buffer)) {}
 154 #endif
 155
 156 SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
 157     return SkNEW_ARGS(SkLayerRasterizer, (ReadLayers(buffer)));
 158 }
 159
 160 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) {
 161     int count = buffer.readInt();
 162
 163     SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)));
 164     for (int i = 0; i < count; i++) {
 165         SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back();
 166
 167         SkNEW_PLACEMENT(&rec->fPaint, SkPaint);
 168         buffer.readPaint(&rec->fPaint);
 169         buffer.readPoint(&rec->fOffset);
 170     }
 171     return layers;
 172 }
 173
 174 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const {
 175     this->INHERITED::flatten(buffer);
 176
 177     SkASSERT(fLayers);
 178     buffer.writeInt(fLayers->count());
 179
 180     SkDeque::F2BIter                iter(*fLayers);
 181     const SkLayerRasterizer_Rec*    rec;
 182
 183     while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
 184         buffer.writePaint(rec->fPaint);
 185         buffer.writePoint(rec->fOffset);
 186     }
 187 }
 188
 189 SkLayerRasterizer::Builder::Builder()
 190         : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
 191 {
 192 }
 193
 194 SkLayerRasterizer::Builder::~Builder()
 195 {
 196     if (fLayers != NULL) {
 197         clean_up_layers(fLayers);
 198     }
 199 }
 200
 201 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx,
 202                                           SkScalar dy) {
 203     SkASSERT(fLayers);
 204     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back();
 205
 206     SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint));
 207     rec->fOffset.set(dx, dy);
 208 }
 209
 210 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
 211     SkLayerRasterizer* rasterizer;
 212     if (0 == fLayers->count()) {
 213         rasterizer = NULL;
 214         SkDELETE(fLayers);
 215     } else {
 216         rasterizer = SkNEW_ARGS(SkLayerRasterizer, (fLayers));
 217     }
 218     fLayers = NULL;
 219     return rasterizer;
 220 }
 221
 222 SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const {
 223     if (0 == fLayers->count()) {
 224         return NULL;
 225     }
 226     SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec), fLayers->count()));
 227     SkDeque::F2BIter                iter(*fLayers);
 228     const SkLayerRasterizer_Rec*    recOrig;
 229     SkDEBUGCODE(int                 count = 0;)
 230     while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != NULL) {
 231         SkDEBUGCODE(count++);
 232         SkLayerRasterizer_Rec* recCopy = static_cast<SkLayerRasterizer_Rec*>(layers->push_back());
 233         SkNEW_PLACEMENT_ARGS(&recCopy->fPaint, SkPaint, (recOrig->fPaint));
 234         recCopy->fOffset = recOrig->fOffset;
 235     }
 236     SkASSERT(fLayers->count() == count);
 237     SkASSERT(layers->count() == count);
 238     SkLayerRasterizer* rasterizer = SkNEW_ARGS(SkLayerRasterizer, (layers));
 239     return rasterizer;
 240 }