The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/gpu/GrDefaultPathRenderer.cpp

gfx/skia/trunk/src/gpu/GrDefaultPathRenderer.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:41421c0babe5
1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "GrDefaultPathRenderer.h"
9
10 #include "GrContext.h"
11 #include "GrDrawState.h"
12 #include "GrPathUtils.h"
13 #include "SkString.h"
14 #include "SkStrokeRec.h"
15 #include "SkTLazy.h"
16 #include "SkTrace.h"
17
18
19 GrDefaultPathRenderer::GrDefaultPathRenderer(bool separateStencilSupport,
20 bool stencilWrapOpsSupport)
21 : fSeparateStencil(separateStencilSupport)
22 , fStencilWrapOps(stencilWrapOpsSupport) {
23 }
24
25
26 ////////////////////////////////////////////////////////////////////////////////
27 // Stencil rules for paths
28
29 ////// Even/Odd
30
31 GR_STATIC_CONST_SAME_STENCIL(gEOStencilPass,
32 kInvert_StencilOp,
33 kKeep_StencilOp,
34 kAlwaysIfInClip_StencilFunc,
35 0xffff,
36 0xffff,
37 0xffff);
38
39 // ok not to check clip b/c stencil pass only wrote inside clip
40 GR_STATIC_CONST_SAME_STENCIL(gEOColorPass,
41 kZero_StencilOp,
42 kZero_StencilOp,
43 kNotEqual_StencilFunc,
44 0xffff,
45 0x0000,
46 0xffff);
47
48 // have to check clip b/c outside clip will always be zero.
49 GR_STATIC_CONST_SAME_STENCIL(gInvEOColorPass,
50 kZero_StencilOp,
51 kZero_StencilOp,
52 kEqualIfInClip_StencilFunc,
53 0xffff,
54 0x0000,
55 0xffff);
56
57 ////// Winding
58
59 // when we have separate stencil we increment front faces / decrement back faces
60 // when we don't have wrap incr and decr we use the stencil test to simulate
61 // them.
62
63 GR_STATIC_CONST_STENCIL(gWindStencilSeparateWithWrap,
64 kIncWrap_StencilOp, kDecWrap_StencilOp,
65 kKeep_StencilOp, kKeep_StencilOp,
66 kAlwaysIfInClip_StencilFunc, kAlwaysIfInClip_StencilFunc,
67 0xffff, 0xffff,
68 0xffff, 0xffff,
69 0xffff, 0xffff);
70
71 // if inc'ing the max value, invert to make 0
72 // if dec'ing zero invert to make all ones.
73 // we can't avoid touching the stencil on both passing and
74 // failing, so we can't resctrict ourselves to the clip.
75 GR_STATIC_CONST_STENCIL(gWindStencilSeparateNoWrap,
76 kInvert_StencilOp, kInvert_StencilOp,
77 kIncClamp_StencilOp, kDecClamp_StencilOp,
78 kEqual_StencilFunc, kEqual_StencilFunc,
79 0xffff, 0xffff,
80 0xffff, 0x0000,
81 0xffff, 0xffff);
82
83 // When there are no separate faces we do two passes to setup the winding rule
84 // stencil. First we draw the front faces and inc, then we draw the back faces
85 // and dec. These are same as the above two split into the incrementing and
86 // decrementing passes.
87 GR_STATIC_CONST_SAME_STENCIL(gWindSingleStencilWithWrapInc,
88 kIncWrap_StencilOp,
89 kKeep_StencilOp,
90 kAlwaysIfInClip_StencilFunc,
91 0xffff,
92 0xffff,
93 0xffff);
94
95 GR_STATIC_CONST_SAME_STENCIL(gWindSingleStencilWithWrapDec,
96 kDecWrap_StencilOp,
97 kKeep_StencilOp,
98 kAlwaysIfInClip_StencilFunc,
99 0xffff,
100 0xffff,
101 0xffff);
102
103 GR_STATIC_CONST_SAME_STENCIL(gWindSingleStencilNoWrapInc,
104 kInvert_StencilOp,
105 kIncClamp_StencilOp,
106 kEqual_StencilFunc,
107 0xffff,
108 0xffff,
109 0xffff);
110
111 GR_STATIC_CONST_SAME_STENCIL(gWindSingleStencilNoWrapDec,
112 kInvert_StencilOp,
113 kDecClamp_StencilOp,
114 kEqual_StencilFunc,
115 0xffff,
116 0x0000,
117 0xffff);
118
119 // Color passes are the same whether we use the two-sided stencil or two passes
120
121 GR_STATIC_CONST_SAME_STENCIL(gWindColorPass,
122 kZero_StencilOp,
123 kZero_StencilOp,
124 kNonZeroIfInClip_StencilFunc,
125 0xffff,
126 0x0000,
127 0xffff);
128
129 GR_STATIC_CONST_SAME_STENCIL(gInvWindColorPass,
130 kZero_StencilOp,
131 kZero_StencilOp,
132 kEqualIfInClip_StencilFunc,
133 0xffff,
134 0x0000,
135 0xffff);
136
137 ////// Normal render to stencil
138
139 // Sometimes the default path renderer can draw a path directly to the stencil
140 // buffer without having to first resolve the interior / exterior.
141 GR_STATIC_CONST_SAME_STENCIL(gDirectToStencil,
142 kZero_StencilOp,
143 kIncClamp_StencilOp,
144 kAlwaysIfInClip_StencilFunc,
145 0xffff,
146 0x0000,
147 0xffff);
148
149 ////////////////////////////////////////////////////////////////////////////////
150 // Helpers for drawPath
151
152 #define STENCIL_OFF 0 // Always disable stencil (even when needed)
153
154 static inline bool single_pass_path(const SkPath& path, const SkStrokeRec& stroke) {
155 #if STENCIL_OFF
156 return true;
157 #else
158 if (!stroke.isHairlineStyle() && !path.isInverseFillType()) {
159 return path.isConvex();
160 }
161 return false;
162 #endif
163 }
164
165 GrPathRenderer::StencilSupport GrDefaultPathRenderer::onGetStencilSupport(
166 const SkPath& path,
167 const SkStrokeRec& stroke,
168 const GrDrawTarget*) const {
169 if (single_pass_path(path, stroke)) {
170 return GrPathRenderer::kNoRestriction_StencilSupport;
171 } else {
172 return GrPathRenderer::kStencilOnly_StencilSupport;
173 }
174 }
175
176 static inline void append_countour_edge_indices(bool hairLine,
177 uint16_t fanCenterIdx,
178 uint16_t edgeV0Idx,
179 uint16_t** indices) {
180 // when drawing lines we're appending line segments along
181 // the contour. When applying the other fill rules we're
182 // drawing triangle fans around fanCenterIdx.
183 if (!hairLine) {
184 *((*indices)++) = fanCenterIdx;
185 }
186 *((*indices)++) = edgeV0Idx;
187 *((*indices)++) = edgeV0Idx + 1;
188 }
189
190 bool GrDefaultPathRenderer::createGeom(const SkPath& path,
191 const SkStrokeRec& stroke,
192 SkScalar srcSpaceTol,
193 GrDrawTarget* target,
194 GrPrimitiveType* primType,
195 int* vertexCnt,
196 int* indexCnt,
197 GrDrawTarget::AutoReleaseGeometry* arg) {
198 {
199 SK_TRACE_EVENT0("GrDefaultPathRenderer::createGeom");
200
201 SkScalar srcSpaceTolSqd = SkScalarMul(srcSpaceTol, srcSpaceTol);
202 int contourCnt;
203 int maxPts = GrPathUtils::worstCasePointCount(path, &contourCnt,
204 srcSpaceTol);
205
206 if (maxPts <= 0) {
207 return false;
208 }
209 if (maxPts > ((int)SK_MaxU16 + 1)) {
210 GrPrintf("Path not rendered, too many verts (%d)\n", maxPts);
211 return false;
212 }
213
214 bool indexed = contourCnt > 1;
215
216 const bool isHairline = stroke.isHairlineStyle();
217
218 int maxIdxs = 0;
219 if (isHairline) {
220 if (indexed) {
221 maxIdxs = 2 * maxPts;
222 *primType = kLines_GrPrimitiveType;
223 } else {
224 *primType = kLineStrip_GrPrimitiveType;
225 }
226 } else {
227 if (indexed) {
228 maxIdxs = 3 * maxPts;
229 *primType = kTriangles_GrPrimitiveType;
230 } else {
231 *primType = kTriangleFan_GrPrimitiveType;
232 }
233 }
234
235 target->drawState()->setDefaultVertexAttribs();
236 if (!arg->set(target, maxPts, maxIdxs)) {
237 return false;
238 }
239
240 uint16_t* idxBase = reinterpret_cast<uint16_t*>(arg->indices());
241 uint16_t* idx = idxBase;
242 uint16_t subpathIdxStart = 0;
243
244 GrPoint* base = reinterpret_cast<GrPoint*>(arg->vertices());
245 SkASSERT(NULL != base);
246 GrPoint* vert = base;
247
248 GrPoint pts[4];
249
250 bool first = true;
251 int subpath = 0;
252
253 SkPath::Iter iter(path, false);
254
255 for (;;) {
256 SkPath::Verb verb = iter.next(pts);
257 switch (verb) {
258 case SkPath::kConic_Verb:
259 SkASSERT(0);
260 break;
261 case SkPath::kMove_Verb:
262 if (!first) {
263 uint16_t currIdx = (uint16_t) (vert - base);
264 subpathIdxStart = currIdx;
265 ++subpath;
266 }
267 *vert = pts[0];
268 vert++;
269 break;
270 case SkPath::kLine_Verb:
271 if (indexed) {
272 uint16_t prevIdx = (uint16_t)(vert - base) - 1;
273 append_countour_edge_indices(isHairline, subpathIdxStart,
274 prevIdx, &idx);
275 }
276 *(vert++) = pts[1];
277 break;
278 case SkPath::kQuad_Verb: {
279 // first pt of quad is the pt we ended on in previous step
280 uint16_t firstQPtIdx = (uint16_t)(vert - base) - 1;
281 uint16_t numPts = (uint16_t)
282 GrPathUtils::generateQuadraticPoints(
283 pts[0], pts[1], pts[2],
284 srcSpaceTolSqd, &vert,
285 GrPathUtils::quadraticPointCount(pts, srcSpaceTol));
286 if (indexed) {
287 for (uint16_t i = 0; i < numPts; ++i) {
288 append_countour_edge_indices(isHairline, subpathIdxStart,
289 firstQPtIdx + i, &idx);
290 }
291 }
292 break;
293 }
294 case SkPath::kCubic_Verb: {
295 // first pt of cubic is the pt we ended on in previous step
296 uint16_t firstCPtIdx = (uint16_t)(vert - base) - 1;
297 uint16_t numPts = (uint16_t) GrPathUtils::generateCubicPoints(
298 pts[0], pts[1], pts[2], pts[3],
299 srcSpaceTolSqd, &vert,
300 GrPathUtils::cubicPointCount(pts, srcSpaceTol));
301 if (indexed) {
302 for (uint16_t i = 0; i < numPts; ++i) {
303 append_countour_edge_indices(isHairline, subpathIdxStart,
304 firstCPtIdx + i, &idx);
305 }
306 }
307 break;
308 }
309 case SkPath::kClose_Verb:
310 break;
311 case SkPath::kDone_Verb:
312 // uint16_t currIdx = (uint16_t) (vert - base);
313 goto FINISHED;
314 }
315 first = false;
316 }
317 FINISHED:
318 SkASSERT((vert - base) <= maxPts);
319 SkASSERT((idx - idxBase) <= maxIdxs);
320
321 *vertexCnt = static_cast<int>(vert - base);
322 *indexCnt = static_cast<int>(idx - idxBase);
323
324 }
325 return true;
326 }
327
328 bool GrDefaultPathRenderer::internalDrawPath(const SkPath& path,
329 const SkStrokeRec& origStroke,
330 GrDrawTarget* target,
331 bool stencilOnly) {
332
333 SkMatrix viewM = target->getDrawState().getViewMatrix();
334 SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
335
336 SkScalar hairlineCoverage;
337 if (IsStrokeHairlineOrEquivalent(*stroke, target->getDrawState().getViewMatrix(),
338 &hairlineCoverage)) {
339 uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage *
340 target->getDrawState().getCoverage());
341 target->drawState()->setCoverage(newCoverage);
342
343 if (!stroke->isHairlineStyle()) {
344 stroke.writable()->setHairlineStyle();
345 }
346 }
347
348 SkScalar tol = SK_Scalar1;
349 tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, path.getBounds());
350
351 int vertexCnt;
352 int indexCnt;
353 GrPrimitiveType primType;
354 GrDrawTarget::AutoReleaseGeometry arg;
355 if (!this->createGeom(path,
356 *stroke,
357 tol,
358 target,
359 &primType,
360 &vertexCnt,
361 &indexCnt,
362 &arg)) {
363 return false;
364 }
365
366 SkASSERT(NULL != target);
367 GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
368 GrDrawState* drawState = target->drawState();
369 bool colorWritesWereDisabled = drawState->isColorWriteDisabled();
370 // face culling doesn't make sense here
371 SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
372
373 int passCount = 0;
374 const GrStencilSettings* passes[3];
375 GrDrawState::DrawFace drawFace[3];
376 bool reverse = false;
377 bool lastPassIsBounds;
378
379 if (stroke->isHairlineStyle()) {
380 passCount = 1;
381 if (stencilOnly) {
382 passes[0] = &gDirectToStencil;
383 } else {
384 passes[0] = NULL;
385 }
386 lastPassIsBounds = false;
387 drawFace[0] = GrDrawState::kBoth_DrawFace;
388 } else {
389 if (single_pass_path(path, *stroke)) {
390 passCount = 1;
391 if (stencilOnly) {
392 passes[0] = &gDirectToStencil;
393 } else {
394 passes[0] = NULL;
395 }
396 drawFace[0] = GrDrawState::kBoth_DrawFace;
397 lastPassIsBounds = false;
398 } else {
399 switch (path.getFillType()) {
400 case SkPath::kInverseEvenOdd_FillType:
401 reverse = true;
402 // fallthrough
403 case SkPath::kEvenOdd_FillType:
404 passes[0] = &gEOStencilPass;
405 if (stencilOnly) {
406 passCount = 1;
407 lastPassIsBounds = false;
408 } else {
409 passCount = 2;
410 lastPassIsBounds = true;
411 if (reverse) {
412 passes[1] = &gInvEOColorPass;
413 } else {
414 passes[1] = &gEOColorPass;
415 }
416 }
417 drawFace[0] = drawFace[1] = GrDrawState::kBoth_DrawFace;
418 break;
419
420 case SkPath::kInverseWinding_FillType:
421 reverse = true;
422 // fallthrough
423 case SkPath::kWinding_FillType:
424 if (fSeparateStencil) {
425 if (fStencilWrapOps) {
426 passes[0] = &gWindStencilSeparateWithWrap;
427 } else {
428 passes[0] = &gWindStencilSeparateNoWrap;
429 }
430 passCount = 2;
431 drawFace[0] = GrDrawState::kBoth_DrawFace;
432 } else {
433 if (fStencilWrapOps) {
434 passes[0] = &gWindSingleStencilWithWrapInc;
435 passes[1] = &gWindSingleStencilWithWrapDec;
436 } else {
437 passes[0] = &gWindSingleStencilNoWrapInc;
438 passes[1] = &gWindSingleStencilNoWrapDec;
439 }
440 // which is cw and which is ccw is arbitrary.
441 drawFace[0] = GrDrawState::kCW_DrawFace;
442 drawFace[1] = GrDrawState::kCCW_DrawFace;
443 passCount = 3;
444 }
445 if (stencilOnly) {
446 lastPassIsBounds = false;
447 --passCount;
448 } else {
449 lastPassIsBounds = true;
450 drawFace[passCount-1] = GrDrawState::kBoth_DrawFace;
451 if (reverse) {
452 passes[passCount-1] = &gInvWindColorPass;
453 } else {
454 passes[passCount-1] = &gWindColorPass;
455 }
456 }
457 break;
458 default:
459 SkDEBUGFAIL("Unknown path fFill!");
460 return false;
461 }
462 }
463 }
464
465 SkRect devBounds;
466 GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
467
468 for (int p = 0; p < passCount; ++p) {
469 drawState->setDrawFace(drawFace[p]);
470 if (NULL != passes[p]) {
471 *drawState->stencil() = *passes[p];
472 }
473
474 if (lastPassIsBounds && (p == passCount-1)) {
475 if (!colorWritesWereDisabled) {
476 drawState->disableState(GrDrawState::kNoColorWrites_StateBit);
477 }
478 SkRect bounds;
479 GrDrawState::AutoViewMatrixRestore avmr;
480 if (reverse) {
481 SkASSERT(NULL != drawState->getRenderTarget());
482 // draw over the dev bounds (which will be the whole dst surface for inv fill).
483 bounds = devBounds;
484 SkMatrix vmi;
485 // mapRect through persp matrix may not be correct
486 if (!drawState->getViewMatrix().hasPerspective() &&
487 drawState->getViewInverse(&vmi)) {
488 vmi.mapRect(&bounds);
489 } else {
490 avmr.setIdentity(drawState);
491 }
492 } else {
493 bounds = path.getBounds();
494 }
495 GrDrawTarget::AutoGeometryAndStatePush agasp(target, GrDrawTarget::kPreserve_ASRInit);
496 target->drawSimpleRect(bounds, NULL);
497 } else {
498 if (passCount > 1) {
499 drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
500 }
501 if (indexCnt) {
502 target->drawIndexed(primType, 0, 0,
503 vertexCnt, indexCnt, &devBounds);
504 } else {
505 target->drawNonIndexed(primType, 0, vertexCnt, &devBounds);
506 }
507 }
508 }
509 return true;
510 }
511
512 bool GrDefaultPathRenderer::canDrawPath(const SkPath& path,
513 const SkStrokeRec& stroke,
514 const GrDrawTarget* target,
515 bool antiAlias) const {
516 // this class can draw any path with any fill but doesn't do any anti-aliasing.
517
518 return !antiAlias &&
519 (stroke.isFillStyle() ||
520 IsStrokeHairlineOrEquivalent(stroke, target->getDrawState().getViewMatrix(), NULL));
521 }
522
523 bool GrDefaultPathRenderer::onDrawPath(const SkPath& path,
524 const SkStrokeRec& stroke,
525 GrDrawTarget* target,
526 bool antiAlias) {
527 return this->internalDrawPath(path,
528 stroke,
529 target,
530 false);
531 }
532
533 void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
534 const SkStrokeRec& stroke,
535 GrDrawTarget* target) {
536 SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
537 SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
538 this->internalDrawPath(path, stroke, target, true);
539 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial