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 } 241
