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 "SkBuffer.h"
12 : #include "SkDraw.h"
13 : #include "SkMask.h"
14 : #include "SkMaskFilter.h"
15 : #include "SkPaint.h"
16 : #include "SkPath.h"
17 : #include "../core/SkRasterClip.h"
18 : #include "SkXfermode.h"
19 : #include <new>
20 :
21 : struct SkLayerRasterizer_Rec {
22 : SkPaint fPaint;
23 : SkVector fOffset;
24 : };
25 :
26 0 : SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec))
27 : {
28 0 : }
29 :
30 0 : SkLayerRasterizer::~SkLayerRasterizer() {
31 0 : SkDeque::F2BIter iter(fLayers);
32 : SkLayerRasterizer_Rec* rec;
33 :
34 0 : while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
35 0 : rec->fPaint.~SkPaint();
36 0 : }
37 :
38 0 : void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx,
39 : SkScalar dy) {
40 0 : SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
41 :
42 0 : new (&rec->fPaint) SkPaint(paint);
43 0 : rec->fOffset.set(dx, dy);
44 0 : }
45 :
46 0 : static bool compute_bounds(const SkDeque& layers, const SkPath& path,
47 : const SkMatrix& matrix,
48 : const SkIRect* clipBounds, SkIRect* bounds) {
49 0 : SkDeque::F2BIter iter(layers);
50 : SkLayerRasterizer_Rec* rec;
51 :
52 0 : bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
53 :
54 0 : while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
55 0 : const SkPaint& paint = rec->fPaint;
56 0 : SkPath fillPath, devPath;
57 0 : const SkPath* p = &path;
58 :
59 0 : if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
60 0 : paint.getFillPath(path, &fillPath);
61 0 : p = &fillPath;
62 : }
63 0 : if (p->isEmpty()) {
64 0 : continue;
65 : }
66 :
67 : // apply the matrix and offset
68 : {
69 0 : SkMatrix m = matrix;
70 0 : m.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
71 0 : p->transform(m, &devPath);
72 : }
73 :
74 : SkMask mask;
75 0 : if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(),
76 : &matrix, &mask,
77 0 : SkMask::kJustComputeBounds_CreateMode)) {
78 0 : return false;
79 : }
80 :
81 0 : bounds->join(mask.fBounds);
82 : }
83 0 : return true;
84 : }
85 :
86 0 : bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
87 : const SkIRect* clipBounds,
88 : SkMask* mask, SkMask::CreateMode mode) {
89 0 : if (fLayers.empty()) {
90 0 : return false;
91 : }
92 :
93 0 : if (SkMask::kJustRenderImage_CreateMode != mode) {
94 0 : if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds))
95 0 : return false;
96 : }
97 :
98 0 : if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
99 0 : mask->fFormat = SkMask::kA8_Format;
100 0 : mask->fRowBytes = mask->fBounds.width();
101 0 : size_t size = mask->computeImageSize();
102 0 : if (0 == size) {
103 0 : return false; // too big to allocate, abort
104 : }
105 0 : mask->fImage = SkMask::AllocImage(size);
106 0 : memset(mask->fImage, 0, size);
107 : }
108 :
109 0 : if (SkMask::kJustComputeBounds_CreateMode != mode) {
110 0 : SkBitmap device;
111 0 : SkRasterClip rectClip;
112 0 : SkDraw draw;
113 : SkMatrix translatedMatrix; // this translates us to our local pixels
114 : SkMatrix drawMatrix; // this translates the path by each layer's offset
115 :
116 0 : rectClip.setRect(SkIRect::MakeWH(mask->fBounds.width(), mask->fBounds.height()));
117 :
118 0 : translatedMatrix = matrix;
119 0 : translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
120 0 : -SkIntToScalar(mask->fBounds.fTop));
121 :
122 0 : device.setConfig(SkBitmap::kA8_Config, mask->fBounds.width(), mask->fBounds.height(), mask->fRowBytes);
123 0 : device.setPixels(mask->fImage);
124 :
125 0 : draw.fBitmap = &device;
126 0 : draw.fMatrix = &drawMatrix;
127 0 : draw.fRC = &rectClip;
128 0 : draw.fClip = &rectClip.bwRgn();
129 : // we set the matrixproc in the loop, as the matrix changes each time (potentially)
130 0 : draw.fBounder = NULL;
131 :
132 0 : SkDeque::F2BIter iter(fLayers);
133 : SkLayerRasterizer_Rec* rec;
134 :
135 0 : while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
136 0 : drawMatrix = translatedMatrix;
137 0 : drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
138 0 : draw.drawPath(path, rec->fPaint);
139 : }
140 : }
141 0 : return true;
142 : }
143 :
144 : /////////// Routines for flattening /////////////////
145 :
146 0 : static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer) {
147 0 : paint->setAntiAlias(buffer.readBool());
148 0 : paint->setStyle((SkPaint::Style)buffer.readU8());
149 0 : paint->setAlpha(buffer.readU8());
150 :
151 0 : if (paint->getStyle() != SkPaint::kFill_Style) {
152 0 : paint->setStrokeWidth(buffer.readScalar());
153 0 : paint->setStrokeMiter(buffer.readScalar());
154 0 : paint->setStrokeCap((SkPaint::Cap)buffer.readU8());
155 0 : paint->setStrokeJoin((SkPaint::Join)buffer.readU8());
156 : }
157 :
158 0 : SkSafeUnref(paint->setMaskFilter((SkMaskFilter*)buffer.readFlattenable()));
159 0 : SkSafeUnref(paint->setPathEffect((SkPathEffect*)buffer.readFlattenable()));
160 0 : SkSafeUnref(paint->setRasterizer((SkRasterizer*)buffer.readFlattenable()));
161 0 : SkSafeUnref(paint->setXfermode((SkXfermode*)buffer.readFlattenable()));
162 0 : }
163 :
164 0 : static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer) {
165 0 : buffer.writeBool(paint.isAntiAlias());
166 0 : buffer.write8(paint.getStyle());
167 0 : buffer.write8(paint.getAlpha());
168 :
169 0 : if (paint.getStyle() != SkPaint::kFill_Style) {
170 0 : buffer.writeScalar(paint.getStrokeWidth());
171 0 : buffer.writeScalar(paint.getStrokeMiter());
172 0 : buffer.write8(paint.getStrokeCap());
173 0 : buffer.write8(paint.getStrokeJoin());
174 : }
175 :
176 0 : buffer.writeFlattenable(paint.getMaskFilter());
177 0 : buffer.writeFlattenable(paint.getPathEffect());
178 0 : buffer.writeFlattenable(paint.getRasterizer());
179 0 : buffer.writeFlattenable(paint.getXfermode());
180 0 : }
181 :
182 0 : SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
183 0 : : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) {
184 0 : int count = buffer.readS32();
185 :
186 0 : for (int i = 0; i < count; i++) {
187 0 : SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
188 :
189 : #if 0
190 : new (&rec->fPaint) SkPaint(buffer);
191 : #else
192 0 : new (&rec->fPaint) SkPaint;
193 0 : paint_read(&rec->fPaint, buffer);
194 : #endif
195 0 : rec->fOffset.fX = buffer.readScalar();
196 0 : rec->fOffset.fY = buffer.readScalar();
197 : }
198 0 : }
199 :
200 0 : void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) {
201 0 : this->INHERITED::flatten(buffer);
202 :
203 0 : buffer.write32(fLayers.count());
204 :
205 0 : SkDeque::F2BIter iter(fLayers);
206 : const SkLayerRasterizer_Rec* rec;
207 :
208 0 : while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
209 : #if 0
210 : rec->fPaint.flatten(buffer);
211 : #else
212 0 : paint_write(rec->fPaint, buffer);
213 : #endif
214 0 : buffer.writeScalar(rec->fOffset.fX);
215 0 : buffer.writeScalar(rec->fOffset.fY);
216 : }
217 0 : }
218 :
219 0 : SkFlattenable* SkLayerRasterizer::CreateProc(SkFlattenableReadBuffer& buffer) {
220 0 : return SkNEW_ARGS(SkLayerRasterizer, (buffer));
221 : }
222 :
223 0 : SkFlattenable::Factory SkLayerRasterizer::getFactory() {
224 0 : return CreateProc;
225 : }
226 :
227 2928 : SK_DEFINE_FLATTENABLE_REGISTRAR(SkLayerRasterizer)
228 :
|