Lines Matching refs:stack
24 // Build up a clip stack with a path, an empty clip, and a rect.
116 static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
118 SkClipStack::B2TIter iter(stack);
129 SkClipStack stack;
140 stack.clipDevRect(gRects[i], SkRegion::kUnion_Op, false);
143 assert_count(reporter, stack, 4);
149 SkClipStack::B2TIter iter(stack);
164 SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
179 SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
242 SkClipStack stack;
251 stack.save();
265 stack.clipDevRect(rectA, SkRegion::kIntersect_Op, false);
266 stack.clipDevRect(rectB, gOps[op], false);
269 stack.clipDevRRect(rrectA, SkRegion::kIntersect_Op, false);
270 stack.clipDevRRect(rrectB, gOps[op], false);
273 stack.clipDevPath(pathA, SkRegion::kIntersect_Op, false);
274 stack.clipDevPath(pathB, gOps[op], false);
278 REPORTER_ASSERT(reporter, !stack.isWideOpen());
279 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
281 stack.getConservativeBounds(0, 0, 100, 100, &devClipBound,
295 stack.restore();
303 // Empty stack is wide open. Wide open stack means that gen id is wide open.
304 SkClipStack stack;
305 REPORTER_ASSERT(reporter, stack.isWideOpen());
306 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
314 // Stack should initially be wide open
316 SkClipStack stack;
318 REPORTER_ASSERT(reporter, stack.isWideOpen());
319 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
324 SkClipStack stack;
334 stack.clipDevPath(clipA, SkRegion::kReplace_Op, false);
335 stack.clipDevPath(clipB, SkRegion::kUnion_Op, false);
337 REPORTER_ASSERT(reporter, stack.isWideOpen());
338 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
343 SkClipStack stack;
345 stack.clipDevRect(rectA, SkRegion::kUnion_Op, false);
347 REPORTER_ASSERT(reporter, stack.isWideOpen());
348 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
353 SkClipStack stack;
358 stack.clipDevRect(emptyRect, SkRegion::kDifference_Op, false);
360 REPORTER_ASSERT(reporter, stack.isWideOpen());
361 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
366 SkClipStack stack;
368 stack.save();
370 stack.clipDevRect(rectA, SkRegion::kReplace_Op, false);
372 REPORTER_ASSERT(reporter, !stack.isWideOpen());
373 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
375 stack.restore();
377 REPORTER_ASSERT(reporter, stack.isWideOpen());
378 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
382 static int count(const SkClipStack& stack) {
384 SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
403 SkClipStack stack;
404 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
408 stack.getBounds(&bounds, &boundsType);
422 // the stack depth. BW replacing BW.
424 SkClipStack stack;
425 REPORTER_ASSERT(reporter, 0 == count(stack));
426 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
427 REPORTER_ASSERT(reporter, 1 == count(stack));
428 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
429 REPORTER_ASSERT(reporter, 1 == count(stack));
433 // the stack depth. AA replacing AA.
435 SkClipStack stack;
436 REPORTER_ASSERT(reporter, 0 == count(stack));
437 stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
438 REPORTER_ASSERT(reporter, 1 == count(stack));
439 stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
440 REPORTER_ASSERT(reporter, 1 == count(stack));
444 // the stack depth. BW replacing AA replacing BW.
446 SkClipStack stack;
447 REPORTER_ASSERT(reporter, 0 == count(stack));
448 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
449 REPORTER_ASSERT(reporter, 1 == count(stack));
450 stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
451 REPORTER_ASSERT(reporter, 1 == count(stack));
452 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
453 REPORTER_ASSERT(reporter, 1 == count(stack));
458 SkClipStack stack;
459 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
460 stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
461 REPORTER_ASSERT(reporter, 1 == count(stack));
463 stack.save();
464 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
465 REPORTER_ASSERT(reporter, 2 == count(stack));
466 stack.getBounds(&bound, &type, &isIntersectionOfRects);
468 stack.restore();
469 REPORTER_ASSERT(reporter, 1 == count(stack));
471 stack.save();
472 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
473 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
474 REPORTER_ASSERT(reporter, 2 == count(stack));
475 stack.restore();
476 REPORTER_ASSERT(reporter, 1 == count(stack));
478 stack.save();
479 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
480 stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
481 stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
482 REPORTER_ASSERT(reporter, 2 == count(stack));
483 stack.restore();
484 REPORTER_ASSERT(reporter, 1 == count(stack));
494 // Replace operation doesn't grow the stack.
496 SkClipStack stack;
497 REPORTER_ASSERT(reporter, 0 == count(stack));
498 stack.clipDevPath(path, SkRegion::kReplace_Op, false);
499 REPORTER_ASSERT(reporter, 1 == count(stack));
500 stack.clipDevPath(path, SkRegion::kReplace_Op, false);
501 REPORTER_ASSERT(reporter, 1 == count(stack));
506 stack;
507 stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
508 REPORTER_ASSERT(reporter, 1 == count(stack));
509 stack.clipDevPath(path, SkRegion::kReplace_Op, true);
510 REPORTER_ASSERT(reporter, 1 == count(stack));
530 SkClipStack stack;
532 stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, false);
534 stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
536 REPORTER_ASSERT(reporter, 1 == count(stack));
538 stack.getBounds(&bound, &type, &isIntersectionOfRects);
545 SkClipStack stack;
547 stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
549 stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, true);
551 REPORTER_ASSERT(reporter, 1 == count(stack));
553 stack.getBounds(&bound, &type, &isIntersectionOfRects);
560 SkClipStack stack;
562 stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
564 stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
566 REPORTER_ASSERT(reporter, 2 == count(stack));
568 stack.getBounds(&bound, &type, &isIntersectionOfRects);
575 SkClipStack stack;
577 stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, true);
579 stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, false);
581 REPORTER_ASSERT(reporter, 1 == count(stack));
583 stack.getBounds(&bound, &type, &isIntersectionOfRects);
590 SkClipStack stack;
592 stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, false);
594 stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, true);
596 REPORTER_ASSERT(reporter, 1 == count(stack));
598 stack.getBounds(&bound, &type, &isIntersectionOfRects);
605 SkClipStack stack;
607 stack.clipDevRect(nestedChild, SkRegion::kReplace_Op, false);
609 stack.clipDevRect(nestedParent, SkRegion::kIntersect_Op, true);
611 REPORTER_ASSERT(reporter, 2 == count(stack));
613 stack.getBounds(&bound, &type, &isIntersectionOfRects);
636 SkClipStack stack;
637 stack.clipDevRect(outsideRect, SkRegion::kDifference_Op, false);
639 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
644 SkClipStack stack;
645 stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
646 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
650 SkClipStack stack;
651 stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
652 stack.save(); // To prevent in-place substitution by replace OP
653 stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
654 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
655 stack.restore();
659 SkClipStack stack;
660 stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
661 stack.save(); // To prevent in-place substitution by replace OP
662 stack.clipDevRect(insideRect, SkRegion::kReplace_Op, false);
663 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
664 stack.restore();
669 SkClipStack stack;
670 stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
672 stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
673 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
678 SkClipStack stack;
679 stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
680 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
684 SkClipStack stack;
685 stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
686 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
690 SkClipStack stack;
691 stack.clipDevRect(intersectingRect, SkRegion::kIntersect_Op, false);
692 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
696 SkClipStack stack;
697 stack.clipDevRect(nonIntersectingRect, SkRegion::kIntersect_Op, false);
698 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
703 SkClipStack stack;
704 stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
705 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
709 SkClipStack stack;
710 stack.clipDevPath(insideCircle, SkRegion::kIntersect_Op, false);
711 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
715 SkClipStack stack;
716 stack.clipDevPath(intersectingCircle, SkRegion::kIntersect_Op, false);
717 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
721 SkClipStack stack;
722 stack.clipDevPath(nonIntersectingCircle, SkRegion::kIntersect_Op, false);
723 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
728 SkClipStack stack;
732 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
733 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
737 SkClipStack stack;
741 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
742 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
746 SkClipStack stack;
750 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
751 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
755 SkClipStack stack;
759 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
760 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
765 SkClipStack stack;
768 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
769 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
773 SkClipStack stack;
776 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
777 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
781 SkClipStack stack;
784 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
785 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
789 SkClipStack stack;
792 stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
793 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
800 // Functions that add a shape to the clip stack. The shape is computed from a rectangle.
801 // AA is always disabled since the clip stack reducer can cause changes in aa rasterization of the
802 // stack. A fractional edge repeated in different elements may be rasterized fewer times using the
803 // reduced stack.
807 SkClipStack* stack);
809 static void add_round_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
816 stack->clipDevPath(path, op, false);
820 stack->clipDevRRect(rrect, op, false);
824 static void add_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
829 stack->clipDevPath(path, op, false);
831 stack->clipDevRect(rect, op, false);
835 static void add_oval(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
841 stack->clipDevPath(path, op, false);
844 static void add_elem_to_stack(const SkClipStack::Element& element, SkClipStack* stack) {
847 stack->clipDevRect(element.getRect(), element.getOp(), element.isAA());
850 stack->clipDevRRect(element.getRRect(), element.getOp(), element.isAA());
853 stack->clipDevPath(element.getPath(), element.getOp(), element.isAA());
857 stack->clipEmpty();
924 // Randomly generate a clip stack.
925 SkClipStack stack;
936 // saves can change the clip stack behavior when an element is added.
950 kElementFuncs[r.nextULessThan(SK_ARRAY_COUNT(kElementFuncs))](rect, invert, op, &stack);
952 stack.save();
962 // Get the reduced version of the stack.
968 GrReducedClip::ReduceClipStack(stack,
977 // Build a new clip stack based on the reduced clip elements
992 // convert both the original stack and reduced stack to SkRegions and see if they're equal
998 SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
1022 SkClipStack stack;
1023 stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op, true);
1024 stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkRegion::kReplace_Op, true);
1032 GrReducedClip::ReduceClipStack(stack,
1044 SkClipStack stack;
1050 stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kReplace_Op, true);
1051 int32_t genIDA = stack.getTopmostGenID();
1052 stack.clipDevRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1053 int32_t genIDB = stack.getTopmostGenID();
1054 stack.clipDevRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1055 int32_t genIDC = stack.getTopmostGenID();
1056 stack.clipDevRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1057 int32_t genIDD = stack.getTopmostGenID();
1127 GrReducedClip::ReduceClipStack(stack,
1149 SkClipStack stack;
1150 stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op);
1151 stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkRegion::kReplace_Op);
1160 GrReducedClip::ReduceClipStack(stack,
1173 SkClipStack stack;
1175 REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1176 assert_count(reporter, stack, 0);
1185 stack.clipDevRect(gRects[i], SkRegion::kIntersect_Op);
1189 SkClipStack::B2TIter iter(stack);
1201 stack.reset();
1202 REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1203 assert_count(reporter, stack, 0);
