Lines Matching refs:stack
54 // Build up a clip stack with a path, an empty clip, and a rect.
146 static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
148 SkClipStack::B2TIter iter(stack);
159 SkClipStack stack;
170 stack.clipRect(gRects[i], SkMatrix::I(), kUnion_SkClipOp, false);
173 assert_count(reporter, stack, 4);
179 SkClipStack::B2TIter iter(stack);
195 SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
211 SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
276 SkClipStack stack;
285 stack.save();
299 stack.clipRect(rectA, SkMatrix::I(), kIntersect_SkClipOp, false);
300 stack.clipRect(rectB, SkMatrix::I(), gOps[op], false);
303 stack.clipRRect(rrectA, SkMatrix::I(), kIntersect_SkClipOp, false);
304 stack.clipRRect(rrectB, SkMatrix::I(), gOps[op], false);
307 stack.clipPath(pathA, SkMatrix::I(), kIntersect_SkClipOp, false);
308 stack.clipPath(pathB, SkMatrix::I(), gOps[op], false);
312 REPORTER_ASSERT(reporter, !stack.isWideOpen());
313 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
315 stack.getConservativeBounds(0, 0, 100, 100, &devClipBound,
329 stack.restore();
337 // Empty stack is wide open. Wide open stack means that gen id is wide open.
338 SkClipStack stack;
339 REPORTER_ASSERT(reporter, stack.isWideOpen());
340 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
348 // Stack should initially be wide open
350 SkClipStack stack;
352 REPORTER_ASSERT(reporter, stack.isWideOpen());
353 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
358 SkClipStack stack;
368 stack.clipPath(clipA, SkMatrix::I(), kReplace_SkClipOp, false);
369 stack.clipPath(clipB, SkMatrix::I(), kUnion_SkClipOp, false);
371 REPORTER_ASSERT(reporter, stack.isWideOpen());
372 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
377 SkClipStack stack;
379 stack.clipRect(rectA, SkMatrix::I(), kUnion_SkClipOp, false);
381 REPORTER_ASSERT(reporter, stack.isWideOpen());
382 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
387 SkClipStack stack;
392 stack.clipRect(emptyRect, SkMatrix::I(), kDifference_SkClipOp, false);
394 REPORTER_ASSERT(reporter, stack.isWideOpen());
395 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
400 SkClipStack stack;
402 stack.save();
404 stack.clipRect(rectA, SkMatrix::I(), kReplace_SkClipOp, false);
406 REPORTER_ASSERT(reporter, !stack.isWideOpen());
407 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
409 stack.restore();
411 REPORTER_ASSERT(reporter, stack.isWideOpen());
412 REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
416 static int count(const SkClipStack& stack) {
418 SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
436 SkClipStack stack;
437 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
441 stack.getBounds(&bounds, &boundsType);
455 // the stack depth. BW replacing BW.
457 SkClipStack stack;
458 REPORTER_ASSERT(reporter, 0 == count(stack));
459 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
460 REPORTER_ASSERT(reporter, 1 == count(stack));
461 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
462 REPORTER_ASSERT(reporter, 1 == count(stack));
466 // the stack depth. AA replacing AA.
468 SkClipStack stack;
469 REPORTER_ASSERT(reporter, 0 == count(stack));
470 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, true);
471 REPORTER_ASSERT(reporter, 1 == count(stack));
472 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, true);
473 REPORTER_ASSERT(reporter, 1 == count(stack));
477 // the stack depth. BW replacing AA replacing BW.
479 SkClipStack stack;
480 REPORTER_ASSERT(reporter, 0 == count(stack));
481 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
482 REPORTER_ASSERT(reporter, 1 == count(stack));
483 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, true);
484 REPORTER_ASSERT(reporter, 1 == count(stack));
485 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
486 REPORTER_ASSERT(reporter, 1 == count(stack));
491 SkClipStack stack;
492 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
493 stack.clipRect(rect2, SkMatrix::I(), kIntersect_SkClipOp, false);
494 REPORTER_ASSERT(reporter, 1 == count(stack));
496 stack.save();
497 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
498 REPORTER_ASSERT(reporter, 2 == count(stack));
499 stack.getBounds(&bound, &type, &isIntersectionOfRects);
501 stack.restore();
502 stack));
504 stack.save();
505 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
506 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
507 REPORTER_ASSERT(reporter, 2 == count(stack));
508 stack.restore();
509 REPORTER_ASSERT(reporter, 1 == count(stack));
511 stack.save();
512 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
513 stack.clipRect(rect2, SkMatrix::I(), kIntersect_SkClipOp, false);
514 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, false);
515 REPORTER_ASSERT(reporter, 2 == count(stack));
516 stack.restore();
517 REPORTER_ASSERT(reporter, 1 == count(stack));
527 // Replace operation doesn't grow the stack.
529 SkClipStack stack;
530 REPORTER_ASSERT(reporter, 0 == count(stack));
531 stack.clipPath(path, SkMatrix::I(), kReplace_SkClipOp, false);
532 REPORTER_ASSERT(reporter, 1 == count(stack));
533 stack.clipPath(path, SkMatrix::I(), kReplace_SkClipOp, false);
534 REPORTER_ASSERT(reporter, 1 == count(stack));
539 SkClipStack stack;
540 stack.clipRect(rect, SkMatrix::I(), kReplace_SkClipOp, true);
541 REPORTER_ASSERT(reporter, 1 == count(stack));
542 stack.clipPath(path, SkMatrix::I(), kReplace_SkClipOp, true);
543 REPORTER_ASSERT(reporter, 1 == count(stack));
563 SkClipStack stack;
565 stack.clipRect(overlapLeft, SkMatrix::I(), kReplace_SkClipOp, false);
567 stack.clipRect(overlapRight, SkMatrix::I(), kIntersect_SkClipOp, false);
569 REPORTER_ASSERT(reporter, 1 == count(stack));
571 stack.getBounds(&bound, &type, &isIntersectionOfRects);
578 SkClipStack stack;
580 stack.clipRect(overlapLeft, SkMatrix::I(), kReplace_SkClipOp, true);
582 stack.clipRect(overlapRight, SkMatrix::I(), kIntersect_SkClipOp, true);
584 REPORTER_ASSERT(reporter, 1 == count(stack));
586 stack.getBounds(&bound, &type, &isIntersectionOfRects);
593 SkClipStack stack;
595 stack.clipRect(overlapLeft, SkMatrix::I(), kReplace_SkClipOp, true);
597 stack.clipRect(overlapRight, SkMatrix::I(), kIntersect_SkClipOp, false);
599 REPORTER_ASSERT(reporter, 2 == count(stack));
601 stack.getBounds(&bound, &type, &isIntersectionOfRects);
608 SkClipStack stack;
610 stack.clipRect(nestedParent, SkMatrix::I(), kReplace_SkClipOp, true);
612 stack.clipRect(nestedChild, SkMatrix::I(), kIntersect_SkClipOp, false);
614 REPORTER_ASSERT(reporter, 1 == count(stack));
616 stack.getBounds(&bound, &type, &isIntersectionOfRects);
623 SkClipStack stack;
625 stack.clipRect(nestedParent, SkMatrix::I(), kReplace_SkClipOp, false);
627 stack.clipRect(nestedChild, SkMatrix::I(), kIntersect_SkClipOp, true);
629 REPORTER_ASSERT(reporter, 1 == count(stack));
631 stack.getBounds(&bound, &type, &isIntersectionOfRects);
638 SkClipStack stack;
640 stack.clipRect(nestedChild, SkMatrix::I(), kReplace_SkClipOp, false);
642 stack.clipRect(nestedParent, SkMatrix::I(), kIntersect_SkClipOp, true);
644 REPORTER_ASSERT(reporter, 2 == count(stack));
646 stack.getBounds(&bound, &type, &isIntersectionOfRects);
669 SkClipStack stack;
670 stack.clipRect(outsideRect, SkMatrix::I(), kDifference_SkClipOp, false);
672 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
677 SkClipStack stack;
678 stack.clipRect(outsideRect, SkMatrix::I(), kReplace_SkClipOp, false);
679 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
683 SkClipStack stack;
684 stack.clipRect(insideRect, SkMatrix::I(), kIntersect_SkClipOp, false);
685 stack.save(); // To prevent in-place substitution by replace OP
686 stack.clipRect(outsideRect, SkMatrix::I(), kReplace_SkClipOp, false);
687 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
688 stack.restore();
692 SkClipStack stack;
693 stack.clipRect(outsideRect, SkMatrix::I(), kIntersect_SkClipOp, false);
694 stack.save(); // To prevent in-place substitution by replace OP
695 stack.clipRect(insideRect, SkMatrix::I(), kReplace_SkClipOp, false);
696 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
697 stack.restore();
702 SkClipStack stack;
703 stack.clipRect(insideRect, SkMatrix::I(), kIntersect_SkClipOp, false);
705 stack.clipPath(outsideCircle, SkMatrix::I(), kIntersect_SkClipOp, false);
706 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
711 SkClipStack stack;
712 stack.clipRect(outsideRect, SkMatrix::I(), kIntersect_SkClipOp, false);
713 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
717 SkClipStack stack;
718 stack.clipRect(insideRect, SkMatrix::I(), kIntersect_SkClipOp, false);
719 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
723 SkClipStack stack;
724 stack.clipRect(intersectingRect, SkMatrix::I(), kIntersect_SkClipOp, false);
725 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
729 SkClipStack stack;
730 stack.clipRect(nonIntersectingRect, SkMatrix::I(), kIntersect_SkClipOp, false);
731 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
736 SkClipStack stack;
737 stack.clipPath(outsideCircle, SkMatrix::I(), kIntersect_SkClipOp, false);
738 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
742 SkClipStack stack;
743 stack.clipPath(insideCircle, SkMatrix::I(), kIntersect_SkClipOp, false);
744 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
748 SkClipStack stack;
749 stack.clipPath(intersectingCircle, SkMatrix::I(), kIntersect_SkClipOp, false);
750 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
754 SkClipStack stack;
755 stack.clipPath(nonIntersectingCircle, SkMatrix::I(), kIntersect_SkClipOp, false);
756 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
761 SkClipStack stack;
765 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
766 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
770 SkClipStack stack;
774 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
775 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
779 SkClipStack stack;
783 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
784 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
788 SkClipStack stack;
792 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
793 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
798 SkClipStack stack;
801 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
802 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
806 SkClipStack stack;
809 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
810 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
814 SkClipStack stack;
817 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
818 REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
822 SkClipStack stack;
825 stack.clipPath(path, SkMatrix::I(), kIntersect_SkClipOp, false);
826 REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
830 static void set_region_to_stack(const SkClipStack& stack, const SkIRect& bounds, SkRegion* region) {
832 SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
852 SkClipStack stack;
853 stack.clipRect({10, 10, 20, 20}, SkMatrix::I(), kIntersect_SkClipOp, false);
858 stack.clipPath(path, SkMatrix::I(), kDifference_SkClipOp, false);
860 REPORTER_ASSERT(reporter, SkClipStack::kEmptyGenID == stack.getTopmostGenID());
864 stack.getBounds(&stackBounds, &stackBoundsType);
870 set_region_to_stack(stack, {0, 0, 50, 30}, ®ion);
877 // Functions that add a shape to the clip stack. The shape is computed from a rectangle.
878 // AA is always disabled since the clip stack reducer can cause changes in aa rasterization of the
879 // stack. A fractional edge repeated in different elements may be rasterized fewer times using the
880 // reduced stack.
884 SkClipStack* stack,
887 static void add_round_rect(const SkRect& rect, bool invert, SkClipOp op, SkClipStack* stack,
895 stack->clipPath(path, SkMatrix::I(), op, doAA);
899 stack->clipRRect(rrect, SkMatrix::I(), op, doAA);
903 static void add_rect(const SkRect& rect, bool invert, SkClipOp op, SkClipStack* stack,
909 stack->clipPath(path, SkMatrix::I(), op, doAA);
911 stack->clipRect(rect, SkMatrix::I(), op, doAA);
915 static void add_oval(const SkRect& rect, bool invert, SkClipOp op, SkClipStack* stack,
922 stack->clipPath(path, SkMatrix::I(), op, doAA);
925 static void add_elem_to_stack(const SkClipStack::Element& element, SkClipStack* stack) {
928 stack->clipRect(element.getDeviceSpaceRect(), SkMatrix::I(), element.getOp(),
932 stack->clipRRect(element.getDeviceSpaceRRect(), SkMatrix::I(), element.getOp(),
936 stack->clipPath(element.getDeviceSpacePath(), SkMatrix::I(), element.getOp(),
941 stack->clipEmpty();
995 // Randomly generate a clip stack.
996 SkClipStack stack;
1008 // saves can change the clip stack behavior when an element is added.
1035 kElementFuncs[r.nextULessThan(SK_ARRAY_COUNT(kElementFuncs))](rect, invert, op, &stack,
1038 stack.save();
1051 // Get the reduced version of the stack.
1054 const GrReducedClip* reduced = new (storage.get()) GrReducedClip(stack, queryBounds, caps);
1065 stack.getBounds(&stackBounds, &stackBoundsType);
1069 // Build a new clip stack based on the reduced clip elements
1083 stack.clipDevRect(scissor, kIntersect_SkClipOp);
1085 // convert both the original stack and reduced stack to SkRegions and see if they're equal
1087 set_region_to_stack(stack, scissor, ®ion);
1106 SkClipStack stack;
1107 stack.clipRect(SkRect::MakeXYWH(0, 0, 100, 100), SkMatrix::I(), kReplace_SkClipOp,
1109 stack.clipRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkMatrix::I(),
1119 const GrReducedClip* reduced = new (storage.get()) GrReducedClip(stack, bounds, caps);
1128 SkClipStack stack;
1134 stack.clipRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkMatrix::I(),
1136 uint32_t genIDA = stack.getTopmostGenID();
1137 stack.clipRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkMatrix::I(),
1139 uint32_t genIDB = stack.getTopmostGenID();
1140 stack.clipRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkMatrix::I(),
1142 uint32_t genIDC = stack.getTopmostGenID();
1143 stack.clipRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkMatrix::I(),
1145 uint32_t genIDD = stack.getTopmostGenID();
1206 const GrReducedClip reduced(stack, testCases[i].testBounds, caps);
1225 SkClipStack stack;
1226 stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), kReplace_SkClipOp);
1227 stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), kReplace_SkClipOp);
1234 const GrReducedClip reduced(stack, bounds, caps);
1246 const SkClipStack& stack, const SkMatrix& queryXform,
1254 const GrReducedClip reduced(stack, queryBounds, caps);
1258 stack.getBounds(&stackBounds, &stackBoundsType);
1331 SkClipStack stack;
1332 stack.clipRect(alignedRect, SkMatrix::I(), kIntersect_SkClipOp, true);
1333 test_aa_query(reporter, name, stack, m, {IL, IT, IR, IB}, ClipMethod::kIgnoreClip);
1334 test_aa_query(reporter, name, stack, m, {IL, IT-1, IR, IT}, ClipMethod::kSkipDraw);
1335 stack, m, {IL, IT-2, IR, IB}, ClipMethod::kScissor);
1339 stack.reset();
1340 stack.clipRect(rect, SkMatrix::I(), kIntersect_SkClipOp, true);
1341 test_aa_query(reporter, name, stack, m, {L, T, R, B}, ClipMethod::kIgnoreClip);
1342 test_aa_query(reporter, name, stack, m, {L-.1f, T, L, B}, ClipMethod::kSkipDraw);
1343 test_aa_query(reporter, name, stack, m, {L-.1f, T, L+.1f, B}, ClipMethod::kAAElements, 1);
1347 stack.reset();
1348 stack.clipRect(rect, SkMatrix::I(), kDifference_SkClipOp, true);
1349 test_aa_query(reporter, name, stack, m, {L, T, R, B}, ClipMethod::kSkipDraw);
1350 test_aa_query(reporter, name, stack, m, {L, T-.1f, R, T}, ClipMethod::kIgnoreClip);
1351 test_aa_query(reporter, name, stack, m, {L, T-.1f, R, T+.1f}, ClipMethod::kAAElements, 1);
1355 stack.reset();
1356 stack.clipRect(rect, SkMatrix::I(), kIntersect_SkClipOp, true);
1357 stack.clipRect(innerRect, SkMatrix::I(), kXOR_SkClipOp, true);
1358 test_aa_query(reporter, name, stack, m, {l, t, r, b}, ClipMethod::kSkipDraw);
1359 test_aa_query(reporter, name, stack, m, {r-.1f, t, R, b}, ClipMethod::kAAElements, 1);
1360 test_aa_query(reporter, name, stack, m, {r-.1f, t, R+.1f, b}, ClipMethod::kAAElements, 2);
1361 test_aa_query(reporter, name, stack, m, {r, t, R+.1f, b}, ClipMethod::kAAElements, 1);
1362 test_aa_query(reporter, name, stack, m, {r, t, R, b}, ClipMethod::kIgnoreClip);
1363 test_aa_query(reporter, name, stack, m, {R, T, R+.1f, B}, ClipMethod::kSkipDraw);
1367 stack.reset();
1368 stack.clipRect(alignedRect, SkMatrix::I(), kIntersect_SkClipOp, true);
1369 stack.clipRect(innerRect, SkMatrix::I(), kXOR_SkClipOp, true);
1370 test_aa_query(reporter, name, stack, m, {l, t, r, b}, ClipMethod::kSkipDraw);
1371 test_aa_query(reporter, name, stack, m, {l, b-.1f, r, IB}, ClipMethod::kAAElements, 1);
1372 test_aa_query(reporter, name, stack, m, {l, b-.1f, r, IB+.1f}, ClipMethod::kAAElements, 1);
1373 test_aa_query(reporter, name, stack, m, {l, b, r, IB+.1f}, ClipMethod::kAAElements, 0);
1374 test_aa_query(reporter, name, stack, m, {l, b, r, IB}, ClipMethod::kIgnoreClip);
1375 test_aa_query(reporter, name, stack, m, {IL, IB, IR, IB+.1f}, ClipMethod::kSkipDraw);
1377 // Apply random transforms and try again. This ensures the clip stack reduction is hardened
1414 for (const SkClipStack& stack : {rectStack, pathStack}) {
1419 const GrReducedClip reduced(stack, queryBounds, caps);
1432 SkClipStack stack;
1434 stack.save();
1435 stack.clipRect(SkRect::MakeLTRB(i, 0.5, kTargetBounds.width(), kTargetBounds.height()),
1442 if (stack.isRRect(kTargetBounds, &rrect, &isAA)) {
1450 SkClipStack stack;
1454 stack.save();
1455 stack.clipRect(SkRect::MakeLTRB(i, j + 0.5, kTargetBounds.width(), kTargetBounds.height()),
1460 REPORTER_ASSERT(reporter, !stack.isRRect(kTargetBounds, &rrect, &isAA));
1464 SkClipStack stack;
1466 REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1467 assert_count(reporter, stack, 0);
1476 stack.clipDevRect(gRects[i], kIntersect_SkClipOp);
1480 SkClipStack::B2TIter iter(stack);
1493 stack.reset();
1494 REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1495 assert_count(reporter, stack, 0);
1530 SkClipStack stack;
1545 stack.save();
1546 stack.clipPath(path, m, SkClipOp::kIntersect, true);
1547 sk_sp<GrTextureProxy> mask = GrClipStackClip(&stack).testingOnly_createClipMask(context);
1558 stack.restore();
