blob: 168fbe91ea349a788da51b36dab71a51f7e78501 [file] [log] [blame]
reed@android.com8a1c16f2008-12-17 15:59:43 +00001/* libs/graphics/effects/SkLayerRasterizer.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
reed@google.com82065d62011-02-07 15:30:46 +00005** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
reed@android.com8a1c16f2008-12-17 15:59:43 +00008**
reed@google.com82065d62011-02-07 15:30:46 +00009** http://www.apache.org/licenses/LICENSE-2.0
reed@android.com8a1c16f2008-12-17 15:59:43 +000010**
reed@google.com82065d62011-02-07 15:30:46 +000011** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
reed@android.com8a1c16f2008-12-17 15:59:43 +000015** limitations under the License.
16*/
17
18#include "SkLayerRasterizer.h"
19#include "SkBuffer.h"
20#include "SkDraw.h"
21#include "SkMask.h"
22#include "SkMaskFilter.h"
23#include "SkPaint.h"
24#include "SkPath.h"
25#include "SkRegion.h"
26#include "SkXfermode.h"
27#include <new>
28
29struct SkLayerRasterizer_Rec {
30 SkPaint fPaint;
31 SkVector fOffset;
32};
33
34SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec))
35{
36}
37
38SkLayerRasterizer::~SkLayerRasterizer()
39{
40 SkDeque::Iter iter(fLayers);
41 SkLayerRasterizer_Rec* rec;
42
43 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
44 rec->fPaint.~SkPaint();
45}
46
47void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx, SkScalar dy)
48{
49 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
50
51 new (&rec->fPaint) SkPaint(paint);
52 rec->fOffset.set(dx, dy);
53}
54
55static bool compute_bounds(const SkDeque& layers, const SkPath& path, const SkMatrix& matrix,
56 const SkIRect* clipBounds, SkIRect* bounds)
57{
58 SkDeque::Iter iter(layers);
59 SkLayerRasterizer_Rec* rec;
60
61 bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
reed@google.com82065d62011-02-07 15:30:46 +000062
reed@android.com8a1c16f2008-12-17 15:59:43 +000063 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
64 {
65 const SkPaint& paint = rec->fPaint;
66 SkPath fillPath, devPath;
67 const SkPath* p = &path;
68
69 if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style)
70 {
71 paint.getFillPath(path, &fillPath);
72 p = &fillPath;
73 }
74 if (p->isEmpty())
75 continue;
76
77 // apply the matrix and offset
78 {
79 SkMatrix m = matrix;
80 m.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
81 p->transform(m, &devPath);
82 }
83
84 SkMask mask;
85 if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(), &matrix,
86 &mask, SkMask::kJustComputeBounds_CreateMode))
87 return false;
88
89 bounds->join(mask.fBounds);
90 }
91 return true;
92}
93
94bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
95 const SkIRect* clipBounds,
96 SkMask* mask, SkMask::CreateMode mode)
97{
98 if (fLayers.empty())
99 return false;
100
101 if (SkMask::kJustRenderImage_CreateMode != mode)
102 {
103 if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds))
104 return false;
105 }
106
107 if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode)
108 {
109 mask->fFormat = SkMask::kA8_Format;
reed@android.com49f0ff22009-03-19 21:52:42 +0000110 mask->fRowBytes = mask->fBounds.width();
reed@android.com543ed932009-04-24 12:43:40 +0000111 size_t size = mask->computeImageSize();
112 if (0 == size) {
113 return false; // too big to allocate, abort
114 }
115 mask->fImage = SkMask::AllocImage(size);
116 memset(mask->fImage, 0, size);
reed@android.com8a1c16f2008-12-17 15:59:43 +0000117 }
118
119 if (SkMask::kJustComputeBounds_CreateMode != mode)
reed@google.com82065d62011-02-07 15:30:46 +0000120 {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000121 SkBitmap device;
122 SkDraw draw;
123 SkMatrix translatedMatrix; // this translates us to our local pixels
124 SkMatrix drawMatrix; // this translates the path by each layer's offset
125 SkRegion rectClip;
reed@google.com82065d62011-02-07 15:30:46 +0000126
reed@android.com8a1c16f2008-12-17 15:59:43 +0000127 rectClip.setRect(0, 0, mask->fBounds.width(), mask->fBounds.height());
128
129 translatedMatrix = matrix;
130 translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
131 -SkIntToScalar(mask->fBounds.fTop));
132
133 device.setConfig(SkBitmap::kA8_Config, mask->fBounds.width(), mask->fBounds.height(), mask->fRowBytes);
134 device.setPixels(mask->fImage);
135
136 draw.fBitmap = &device;
137 draw.fMatrix = &drawMatrix;
138 draw.fClip = &rectClip;
139 // we set the matrixproc in the loop, as the matrix changes each time (potentially)
140 draw.fBounder = NULL;
reed@google.com82065d62011-02-07 15:30:46 +0000141
reed@android.com8a1c16f2008-12-17 15:59:43 +0000142 SkDeque::Iter iter(fLayers);
143 SkLayerRasterizer_Rec* rec;
144
145 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
146 drawMatrix = translatedMatrix;
147 drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
148 draw.drawPath(path, rec->fPaint);
149 }
150 }
151 return true;
152}
153
154/////////// Routines for flattening /////////////////
155
156static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer)
157{
158 paint->setAntiAlias(buffer.readBool());
159 paint->setStyle((SkPaint::Style)buffer.readU8());
160 paint->setAlpha(buffer.readU8());
reed@google.com82065d62011-02-07 15:30:46 +0000161
reed@android.com8a1c16f2008-12-17 15:59:43 +0000162 if (paint->getStyle() != SkPaint::kFill_Style)
163 {
164 paint->setStrokeWidth(buffer.readScalar());
165 paint->setStrokeMiter(buffer.readScalar());
166 paint->setStrokeCap((SkPaint::Cap)buffer.readU8());
167 paint->setStrokeJoin((SkPaint::Join)buffer.readU8());
168 }
169
reed@google.com82065d62011-02-07 15:30:46 +0000170 SkSafeUnref(paint->setMaskFilter((SkMaskFilter*)buffer.readFlattenable()));
171 SkSafeUnref(paint->setPathEffect((SkPathEffect*)buffer.readFlattenable()));
172 SkSafeUnref(paint->setRasterizer((SkRasterizer*)buffer.readFlattenable()));
173 SkSafeUnref(paint->setXfermode((SkXfermode*)buffer.readFlattenable()));
reed@android.com8a1c16f2008-12-17 15:59:43 +0000174}
175
176static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer)
177{
178 buffer.writeBool(paint.isAntiAlias());
179 buffer.write8(paint.getStyle());
180 buffer.write8(paint.getAlpha());
reed@google.com82065d62011-02-07 15:30:46 +0000181
reed@android.com8a1c16f2008-12-17 15:59:43 +0000182 if (paint.getStyle() != SkPaint::kFill_Style)
183 {
184 buffer.writeScalar(paint.getStrokeWidth());
185 buffer.writeScalar(paint.getStrokeMiter());
186 buffer.write8(paint.getStrokeCap());
187 buffer.write8(paint.getStrokeJoin());
188 }
reed@google.com82065d62011-02-07 15:30:46 +0000189
reed@android.com8a1c16f2008-12-17 15:59:43 +0000190 buffer.writeFlattenable(paint.getMaskFilter());
191 buffer.writeFlattenable(paint.getPathEffect());
192 buffer.writeFlattenable(paint.getRasterizer());
193 buffer.writeFlattenable(paint.getXfermode());
194}
195
196SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
197 : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec))
198{
199 int count = buffer.readS32();
reed@google.com82065d62011-02-07 15:30:46 +0000200
reed@android.com8a1c16f2008-12-17 15:59:43 +0000201 for (int i = 0; i < count; i++)
202 {
203 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
reed@google.com82065d62011-02-07 15:30:46 +0000204
reed@android.com8a1c16f2008-12-17 15:59:43 +0000205#if 0
206 new (&rec->fPaint) SkPaint(buffer);
207#else
208 new (&rec->fPaint) SkPaint;
209 paint_read(&rec->fPaint, buffer);
210#endif
211 rec->fOffset.fX = buffer.readScalar();
212 rec->fOffset.fY = buffer.readScalar();
213 }
214}
215
216void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer)
217{
218 this->INHERITED::flatten(buffer);
219
220 buffer.write32(fLayers.count());
221
222 SkDeque::Iter iter(fLayers);
223 const SkLayerRasterizer_Rec* rec;
224
225 while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL)
226 {
227#if 0
228 rec->fPaint.flatten(buffer);
229#else
230 paint_write(rec->fPaint, buffer);
231#endif
232 buffer.writeScalar(rec->fOffset.fX);
233 buffer.writeScalar(rec->fOffset.fY);
234 }
235}
236
237SkFlattenable* SkLayerRasterizer::CreateProc(SkFlattenableReadBuffer& buffer)
238{
239 return SkNEW_ARGS(SkLayerRasterizer, (buffer));
240}
241
242SkFlattenable::Factory SkLayerRasterizer::getFactory()
243{
244 return CreateProc;
245}
246