OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2006 The Android Open Source Project | 3 * Copyright 2006 The Android Open Source Project |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 | 9 |
10 #include "SkLayerRasterizer.h" | 10 #include "SkLayerRasterizer.h" |
11 #include "SkDraw.h" | 11 #include "SkDraw.h" |
12 #include "SkReadBuffer.h" | 12 #include "SkReadBuffer.h" |
13 #include "SkWriteBuffer.h" | 13 #include "SkWriteBuffer.h" |
14 #include "SkMask.h" | 14 #include "SkMask.h" |
15 #include "SkMaskFilter.h" | 15 #include "SkMaskFilter.h" |
16 #include "SkPaint.h" | 16 #include "SkPaint.h" |
17 #include "SkPath.h" | 17 #include "SkPath.h" |
18 #include "SkPathEffect.h" | 18 #include "SkPathEffect.h" |
19 #include "../core/SkRasterClip.h" | 19 #include "../core/SkRasterClip.h" |
20 #include "SkXfermode.h" | 20 #include "SkXfermode.h" |
21 #include <new> | 21 #include <new> |
22 | 22 |
23 struct SkLayerRasterizer_Rec { | 23 struct SkLayerRasterizer_Rec { |
24 SkPaint fPaint; | 24 SkPaint fPaint; |
25 SkVector fOffset; | 25 SkVector fOffset; |
26 }; | 26 }; |
27 | 27 |
28 SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec)) | 28 SkLayerRasterizer::SkLayerRasterizer() |
| 29 : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)))) |
| 30 { |
| 31 } |
| 32 |
| 33 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers) |
29 { | 34 { |
30 } | 35 } |
31 | 36 |
32 SkLayerRasterizer::~SkLayerRasterizer() { | 37 SkLayerRasterizer::~SkLayerRasterizer() { |
33 SkDeque::F2BIter iter(fLayers); | 38 SkASSERT(fLayers); |
| 39 SkDeque::F2BIter iter(*fLayers); |
34 SkLayerRasterizer_Rec* rec; | 40 SkLayerRasterizer_Rec* rec; |
35 | 41 |
36 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) | 42 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) |
37 rec->fPaint.~SkPaint(); | 43 rec->fPaint.~SkPaint(); |
| 44 |
| 45 SkDELETE(fLayers); |
38 } | 46 } |
39 | 47 |
| 48 #ifdef SK_SUPPORT_LEGACY_LAYERRASTERIZER_API |
40 void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx, | 49 void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx, |
41 SkScalar dy) { | 50 SkScalar dy) { |
42 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back(); | 51 SkASSERT(fLayers); |
| 52 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back(); |
43 | 53 |
44 SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint)); | 54 SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint)); |
45 rec->fOffset.set(dx, dy); | 55 rec->fOffset.set(dx, dy); |
46 } | 56 } |
| 57 #endif |
47 | 58 |
48 static bool compute_bounds(const SkDeque& layers, const SkPath& path, | 59 static bool compute_bounds(const SkDeque& layers, const SkPath& path, |
49 const SkMatrix& matrix, | 60 const SkMatrix& matrix, |
50 const SkIRect* clipBounds, SkIRect* bounds) { | 61 const SkIRect* clipBounds, SkIRect* bounds) { |
51 SkDeque::F2BIter iter(layers); | 62 SkDeque::F2BIter iter(layers); |
52 SkLayerRasterizer_Rec* rec; | 63 SkLayerRasterizer_Rec* rec; |
53 | 64 |
54 bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32); | 65 bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32); |
55 | 66 |
56 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { | 67 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { |
(...skipping 25 matching lines...) Expand all Loading... |
82 } | 93 } |
83 | 94 |
84 bounds->join(mask.fBounds); | 95 bounds->join(mask.fBounds); |
85 } | 96 } |
86 return true; | 97 return true; |
87 } | 98 } |
88 | 99 |
89 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix, | 100 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix, |
90 const SkIRect* clipBounds, | 101 const SkIRect* clipBounds, |
91 SkMask* mask, SkMask::CreateMode mode) const
{ | 102 SkMask* mask, SkMask::CreateMode mode) const
{ |
92 if (fLayers.empty()) { | 103 SkASSERT(fLayers); |
| 104 if (fLayers->empty()) { |
93 return false; | 105 return false; |
94 } | 106 } |
95 | 107 |
96 if (SkMask::kJustRenderImage_CreateMode != mode) { | 108 if (SkMask::kJustRenderImage_CreateMode != mode) { |
97 if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds)) | 109 if (!compute_bounds(*fLayers, path, matrix, clipBounds, &mask->fBounds)) |
98 return false; | 110 return false; |
99 } | 111 } |
100 | 112 |
101 if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) { | 113 if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) { |
102 mask->fFormat = SkMask::kA8_Format; | 114 mask->fFormat = SkMask::kA8_Format; |
103 mask->fRowBytes = mask->fBounds.width(); | 115 mask->fRowBytes = mask->fBounds.width(); |
104 size_t size = mask->computeImageSize(); | 116 size_t size = mask->computeImageSize(); |
105 if (0 == size) { | 117 if (0 == size) { |
106 return false; // too big to allocate, abort | 118 return false; // too big to allocate, abort |
107 } | 119 } |
(...skipping 16 matching lines...) Expand all Loading... |
124 | 136 |
125 device.installMaskPixels(*mask); | 137 device.installMaskPixels(*mask); |
126 | 138 |
127 draw.fBitmap = &device; | 139 draw.fBitmap = &device; |
128 draw.fMatrix = &drawMatrix; | 140 draw.fMatrix = &drawMatrix; |
129 draw.fRC = &rectClip; | 141 draw.fRC = &rectClip; |
130 draw.fClip = &rectClip.bwRgn(); | 142 draw.fClip = &rectClip.bwRgn(); |
131 // we set the matrixproc in the loop, as the matrix changes each time (p
otentially) | 143 // we set the matrixproc in the loop, as the matrix changes each time (p
otentially) |
132 draw.fBounder = NULL; | 144 draw.fBounder = NULL; |
133 | 145 |
134 SkDeque::F2BIter iter(fLayers); | 146 SkDeque::F2BIter iter(*fLayers); |
135 SkLayerRasterizer_Rec* rec; | 147 SkLayerRasterizer_Rec* rec; |
136 | 148 |
137 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { | 149 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { |
138 drawMatrix = translatedMatrix; | 150 drawMatrix = translatedMatrix; |
139 drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY); | 151 drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY); |
140 draw.drawPath(path, rec->fPaint); | 152 draw.drawPath(path, rec->fPaint); |
141 } | 153 } |
142 } | 154 } |
143 return true; | 155 return true; |
144 } | 156 } |
145 | 157 |
146 SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer) | 158 SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer) |
147 : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) { | 159 : SkRasterizer(buffer), fLayers(ReadLayers(buffer)) {} |
| 160 |
| 161 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) { |
148 int count = buffer.readInt(); | 162 int count = buffer.readInt(); |
149 | 163 |
| 164 SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))); |
150 for (int i = 0; i < count; i++) { | 165 for (int i = 0; i < count; i++) { |
151 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back()
; | 166 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back()
; |
152 | 167 |
153 SkNEW_PLACEMENT(&rec->fPaint, SkPaint); | 168 SkNEW_PLACEMENT(&rec->fPaint, SkPaint); |
154 buffer.readPaint(&rec->fPaint); | 169 buffer.readPaint(&rec->fPaint); |
155 buffer.readPoint(&rec->fOffset); | 170 buffer.readPoint(&rec->fOffset); |
156 } | 171 } |
| 172 return layers; |
157 } | 173 } |
158 | 174 |
159 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const { | 175 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const { |
160 this->INHERITED::flatten(buffer); | 176 this->INHERITED::flatten(buffer); |
161 | 177 |
162 buffer.writeInt(fLayers.count()); | 178 SkASSERT(fLayers); |
| 179 buffer.writeInt(fLayers->count()); |
163 | 180 |
164 SkDeque::F2BIter iter(fLayers); | 181 SkDeque::F2BIter iter(*fLayers); |
165 const SkLayerRasterizer_Rec* rec; | 182 const SkLayerRasterizer_Rec* rec; |
166 | 183 |
167 while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) { | 184 while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) { |
168 buffer.writePaint(rec->fPaint); | 185 buffer.writePaint(rec->fPaint); |
169 buffer.writePoint(rec->fOffset); | 186 buffer.writePoint(rec->fOffset); |
170 } | 187 } |
171 } | 188 } |
| 189 |
| 190 SkLayerRasterizer::Builder::Builder() |
| 191 : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)))) |
| 192 { |
| 193 } |
| 194 |
| 195 SkLayerRasterizer::Builder::~Builder() |
| 196 { |
| 197 SkDELETE(fLayers); |
| 198 } |
| 199 |
| 200 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx, |
| 201 SkScalar dy) { |
| 202 SkASSERT(fLayers); |
| 203 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back(); |
| 204 |
| 205 SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint)); |
| 206 rec->fOffset.set(dx, dy); |
| 207 } |
| 208 |
| 209 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() { |
| 210 SkLayerRasterizer* rasterizer = SkNEW_ARGS(SkLayerRasterizer, (fLayers)); |
| 211 fLayers = NULL; |
| 212 return rasterizer; |
| 213 } |
OLD | NEW |