OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 Google Inc. |
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 // This test only works with the GPU backend. | 9 // This test only works with the GPU backend. |
10 | 10 |
11 #include "gm.h" | 11 #include "gm.h" |
12 | 12 |
13 #if SK_SUPPORT_GPU | 13 #if SK_SUPPORT_GPU |
14 | 14 |
15 #include "GrContext.h" | 15 #include "GrContext.h" |
16 #include "GrDefaultGeoProcFactory.h" | 16 #include "GrDefaultGeoProcFactory.h" |
| 17 #include "GrDrawContext.h" |
17 #include "GrPathUtils.h" | 18 #include "GrPathUtils.h" |
18 #include "GrTest.h" | 19 #include "GrTest.h" |
19 #include "SkColorPriv.h" | 20 #include "SkColorPriv.h" |
20 #include "SkDevice.h" | 21 #include "SkDevice.h" |
21 #include "SkGeometry.h" | 22 #include "SkGeometry.h" |
22 #include "SkTLList.h" | 23 #include "SkTLList.h" |
23 | 24 |
24 #include "batches/GrTestBatch.h" | 25 #include "batches/GrTestBatch.h" |
25 #include "batches/GrVertexBatch.h" | 26 #include "batches/GrVertexBatch.h" |
26 | 27 |
27 #include "effects/GrConvexPolyEffect.h" | 28 #include "effects/GrConvexPolyEffect.h" |
28 | 29 |
29 namespace skiagm { | 30 namespace skiagm { |
30 | 31 |
31 class ConvexPolyTestBatch : public GrTestBatch { | 32 class ConvexPolyTestBatch : public GrTestBatch { |
32 public: | 33 public: |
33 DEFINE_BATCH_CLASS_ID | 34 DEFINE_BATCH_CLASS_ID |
34 struct Geometry : public GrTestBatch::Geometry { | 35 struct Geometry : public GrTestBatch::Geometry { |
35 SkRect fBounds; | 36 SkRect fRect; |
| 37 SkRect fBounds; // This will be == fRect, except fBounds must be sorted,
whereas fRect can |
| 38 // be inverted |
36 }; | 39 }; |
37 | 40 |
38 const char* name() const override { return "ConvexPolyTestBatch"; } | 41 const char* name() const override { return "ConvexPolyTestBatch"; } |
39 | 42 |
40 static GrDrawBatch* Create(const GrGeometryProcessor* gp, const Geometry& ge
o) { | 43 static GrDrawBatch* Create(const GrGeometryProcessor* gp, const Geometry& ge
o) { |
41 return new ConvexPolyTestBatch(gp, geo); | 44 return new ConvexPolyTestBatch(gp, geo); |
42 } | 45 } |
43 | 46 |
44 private: | 47 private: |
45 ConvexPolyTestBatch(const GrGeometryProcessor* gp, const Geometry& geo) | 48 ConvexPolyTestBatch(const GrGeometryProcessor* gp, const Geometry& geo) |
46 : INHERITED(ClassID(), gp, geo.fBounds) | 49 : INHERITED(ClassID(), gp, geo.fBounds) |
47 , fGeometry(geo) { | 50 , fGeometry(geo) { |
48 // Make sure any artifacts around the exterior of path are visible by us
ing overly | 51 // Make sure any artifacts around the exterior of path are visible by us
ing overly |
49 // conservative bounding geometry. | 52 // conservative bounding geometry. |
50 fGeometry.fBounds.outset(5.f, 5.f); | 53 fGeometry.fBounds.outset(5.f, 5.f); |
| 54 fGeometry.fRect.outset(5.f, 5.f); |
51 } | 55 } |
52 | 56 |
53 Geometry* geoData(int index) override { | 57 Geometry* geoData(int index) override { |
54 SkASSERT(0 == index); | 58 SkASSERT(0 == index); |
55 return &fGeometry; | 59 return &fGeometry; |
56 } | 60 } |
57 | 61 |
58 const Geometry* geoData(int index) const override { | 62 const Geometry* geoData(int index) const override { |
59 SkASSERT(0 == index); | 63 SkASSERT(0 == index); |
60 return &fGeometry; | 64 return &fGeometry; |
61 } | 65 } |
62 | 66 |
63 void generateGeometry(Target* target) const override { | 67 void generateGeometry(Target* target) const override { |
64 size_t vertexStride = this->geometryProcessor()->getVertexStride(); | 68 size_t vertexStride = this->geometryProcessor()->getVertexStride(); |
65 SkASSERT(vertexStride == sizeof(SkPoint)); | 69 SkASSERT(vertexStride == sizeof(SkPoint)); |
66 QuadHelper helper; | 70 QuadHelper helper; |
67 SkPoint* verts = reinterpret_cast<SkPoint*>(helper.init(target, vertexSt
ride, 1)); | 71 SkPoint* verts = reinterpret_cast<SkPoint*>(helper.init(target, vertexSt
ride, 1)); |
68 if (!verts) { | 72 if (!verts) { |
69 return; | 73 return; |
70 } | 74 } |
71 | 75 |
72 fGeometry.fBounds.toQuad(verts); | 76 fGeometry.fRect.toQuad(verts); |
73 | 77 |
74 helper.recordDraw(target); | 78 helper.recordDraw(target); |
75 } | 79 } |
76 | 80 |
77 Geometry fGeometry; | 81 Geometry fGeometry; |
78 | 82 |
79 typedef GrTestBatch INHERITED; | 83 typedef GrTestBatch INHERITED; |
80 }; | 84 }; |
81 | 85 |
82 /** | 86 /** |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
152 GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget
(); | 156 GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget
(); |
153 if (nullptr == rt) { | 157 if (nullptr == rt) { |
154 skiagm::GM::DrawGpuOnlyMessage(canvas); | 158 skiagm::GM::DrawGpuOnlyMessage(canvas); |
155 return; | 159 return; |
156 } | 160 } |
157 GrContext* context = rt->getContext(); | 161 GrContext* context = rt->getContext(); |
158 if (nullptr == context) { | 162 if (nullptr == context) { |
159 return; | 163 return; |
160 } | 164 } |
161 | 165 |
| 166 SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(rt)); |
| 167 if (!drawContext) { |
| 168 return; |
| 169 } |
| 170 |
162 Color color(0xff000000); | 171 Color color(0xff000000); |
163 Coverage coverage(Coverage::kSolid_Type); | 172 Coverage coverage(Coverage::kSolid_Type); |
164 LocalCoords localCoords(LocalCoords::kUnused_Type); | 173 LocalCoords localCoords(LocalCoords::kUnused_Type); |
165 SkAutoTUnref<const GrGeometryProcessor> gp( | 174 SkAutoTUnref<const GrGeometryProcessor> gp( |
166 GrDefaultGeoProcFactory::Create(color, coverage, localCoords, Sk
Matrix::I())); | 175 GrDefaultGeoProcFactory::Create(color, coverage, localCoords, Sk
Matrix::I())); |
167 | 176 |
168 SkScalar y = 0; | 177 SkScalar y = 0; |
169 for (PathList::Iter iter(fPaths, PathList::Iter::kHead_IterStart); | 178 for (PathList::Iter iter(fPaths, PathList::Iter::kHead_IterStart); |
170 iter.get(); | 179 iter.get(); |
171 iter.next()) { | 180 iter.next()) { |
172 const SkPath* path = iter.get(); | 181 const SkPath* path = iter.get(); |
173 SkScalar x = 0; | 182 SkScalar x = 0; |
174 | 183 |
175 for (int et = 0; et < kGrProcessorEdgeTypeCnt; ++et) { | 184 for (int et = 0; et < kGrProcessorEdgeTypeCnt; ++et) { |
176 GrTestTarget tt; | |
177 context->getTestTarget(&tt, rt); | |
178 if (nullptr == tt.target()) { | |
179 SkDEBUGFAIL("Couldn't get Gr test target."); | |
180 return; | |
181 } | |
182 const SkMatrix m = SkMatrix::MakeTrans(x, y); | 185 const SkMatrix m = SkMatrix::MakeTrans(x, y); |
183 SkPath p; | 186 SkPath p; |
184 path->transform(m, &p); | 187 path->transform(m, &p); |
185 | 188 |
186 GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et; | 189 GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et; |
187 SkAutoTUnref<GrFragmentProcessor> fp(GrConvexPolyEffect::Create(
edgeType, p)); | 190 SkAutoTUnref<GrFragmentProcessor> fp(GrConvexPolyEffect::Create(
edgeType, p)); |
188 if (!fp) { | 191 if (!fp) { |
189 continue; | 192 continue; |
190 } | 193 } |
191 | 194 |
192 GrPipelineBuilder pipelineBuilder; | 195 GrPipelineBuilder pipelineBuilder; |
193 pipelineBuilder.setXPFactory( | 196 pipelineBuilder.setXPFactory( |
194 GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref
(); | 197 GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref
(); |
195 pipelineBuilder.addCoverageFragmentProcessor(fp); | 198 pipelineBuilder.addCoverageFragmentProcessor(fp); |
196 pipelineBuilder.setRenderTarget(rt); | 199 pipelineBuilder.setRenderTarget(rt); |
197 | 200 |
198 ConvexPolyTestBatch::Geometry geometry; | 201 ConvexPolyTestBatch::Geometry geometry; |
199 geometry.fColor = color.fColor; | 202 geometry.fColor = color.fColor; |
| 203 geometry.fRect = p.getBounds(); |
200 geometry.fBounds = p.getBounds(); | 204 geometry.fBounds = p.getBounds(); |
201 | 205 |
202 SkAutoTUnref<GrDrawBatch> batch(ConvexPolyTestBatch::Create(gp,
geometry)); | 206 SkAutoTUnref<GrDrawBatch> batch(ConvexPolyTestBatch::Create(gp,
geometry)); |
203 | 207 |
204 tt.target()->drawBatch(pipelineBuilder, batch); | 208 drawContext->internal_drawBatch(pipelineBuilder, batch); |
205 | 209 |
206 x += SkScalarCeilToScalar(path->getBounds().width() + 10.f); | 210 x += SkScalarCeilToScalar(path->getBounds().width() + 10.f); |
207 } | 211 } |
208 | 212 |
209 // Draw AA and non AA paths using normal API for reference. | 213 // Draw AA and non AA paths using normal API for reference. |
210 canvas->save(); | 214 canvas->save(); |
211 canvas->translate(x, y); | 215 canvas->translate(x, y); |
212 SkPaint paint; | 216 SkPaint paint; |
213 canvas->drawPath(*path, paint); | 217 canvas->drawPath(*path, paint); |
214 canvas->translate(path->getBounds().width() + 10.f, 0); | 218 canvas->translate(path->getBounds().width() + 10.f, 0); |
215 paint.setAntiAlias(true); | 219 paint.setAntiAlias(true); |
216 canvas->drawPath(*path, paint); | 220 canvas->drawPath(*path, paint); |
217 canvas->restore(); | 221 canvas->restore(); |
218 | 222 |
219 y += SkScalarCeilToScalar(path->getBounds().height() + 20.f); | 223 y += SkScalarCeilToScalar(path->getBounds().height() + 20.f); |
220 } | 224 } |
221 | 225 |
222 for (RectList::Iter iter(fRects, RectList::Iter::kHead_IterStart); | 226 for (RectList::Iter iter(fRects, RectList::Iter::kHead_IterStart); |
223 iter.get(); | 227 iter.get(); |
224 iter.next()) { | 228 iter.next()) { |
225 | 229 |
226 SkScalar x = 0; | 230 SkScalar x = 0; |
227 | 231 |
228 for (int et = 0; et < kGrProcessorEdgeTypeCnt; ++et) { | 232 for (int et = 0; et < kGrProcessorEdgeTypeCnt; ++et) { |
229 GrTestTarget tt; | |
230 context->getTestTarget(&tt, rt); | |
231 if (nullptr == tt.target()) { | |
232 SkDEBUGFAIL("Couldn't get Gr test target."); | |
233 return; | |
234 } | |
235 SkRect rect = *iter.get(); | 233 SkRect rect = *iter.get(); |
236 rect.offset(x, y); | 234 rect.offset(x, y); |
237 GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et; | 235 GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et; |
238 SkAutoTUnref<GrFragmentProcessor> fp(GrConvexPolyEffect::Create(
edgeType, rect)); | 236 SkAutoTUnref<GrFragmentProcessor> fp(GrConvexPolyEffect::Create(
edgeType, rect)); |
239 if (!fp) { | 237 if (!fp) { |
240 continue; | 238 continue; |
241 } | 239 } |
242 | 240 |
243 GrPipelineBuilder pipelineBuilder; | 241 GrPipelineBuilder pipelineBuilder; |
244 pipelineBuilder.setXPFactory( | 242 pipelineBuilder.setXPFactory( |
245 GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref
(); | 243 GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref
(); |
246 pipelineBuilder.addCoverageFragmentProcessor(fp); | 244 pipelineBuilder.addCoverageFragmentProcessor(fp); |
247 pipelineBuilder.setRenderTarget(rt); | 245 pipelineBuilder.setRenderTarget(rt); |
248 | 246 |
249 ConvexPolyTestBatch::Geometry geometry; | 247 ConvexPolyTestBatch::Geometry geometry; |
250 geometry.fColor = color.fColor; | 248 geometry.fColor = color.fColor; |
| 249 geometry.fRect = rect; |
251 geometry.fBounds = rect; | 250 geometry.fBounds = rect; |
| 251 geometry.fBounds.sort(); |
252 | 252 |
253 SkAutoTUnref<GrDrawBatch> batch(ConvexPolyTestBatch::Create(gp,
geometry)); | 253 SkAutoTUnref<GrDrawBatch> batch(ConvexPolyTestBatch::Create(gp,
geometry)); |
254 | 254 |
255 tt.target()->drawBatch(pipelineBuilder, batch); | 255 drawContext->internal_drawBatch(pipelineBuilder, batch); |
256 | 256 |
257 x += SkScalarCeilToScalar(rect.width() + 10.f); | 257 x += SkScalarCeilToScalar(rect.width() + 10.f); |
258 } | 258 } |
259 | 259 |
260 // Draw rect without and with AA using normal API for reference | 260 // Draw rect without and with AA using normal API for reference |
261 canvas->save(); | 261 canvas->save(); |
262 canvas->translate(x, y); | 262 canvas->translate(x, y); |
263 SkPaint paint; | 263 SkPaint paint; |
264 canvas->drawRect(*iter.get(), paint); | 264 canvas->drawRect(*iter.get(), paint); |
265 x += SkScalarCeilToScalar(iter.get()->width() + 10.f); | 265 x += SkScalarCeilToScalar(iter.get()->width() + 10.f); |
(...skipping 11 matching lines...) Expand all Loading... |
277 PathList fPaths; | 277 PathList fPaths; |
278 RectList fRects; | 278 RectList fRects; |
279 | 279 |
280 typedef GM INHERITED; | 280 typedef GM INHERITED; |
281 }; | 281 }; |
282 | 282 |
283 DEF_GM(return new ConvexPolyEffect;) | 283 DEF_GM(return new ConvexPolyEffect;) |
284 } | 284 } |
285 | 285 |
286 #endif | 286 #endif |
OLD | NEW |