tests/GrQuadCropTest.cpp - platform/external/skia - Git at Google


            
            /*

            
             * Copyright 2019 Google LLC

            
             *

            
             * Use of this source code is governed by a BSD-style license that can be

            
             * found in the LICENSE file.

            
             */


            #include "include/core/SkMatrix.h"

            
            #include "include/core/SkPoint.h"

            
            #include "include/core/SkRect.h"

            
            #include "include/core/SkScalar.h"

            
            #include "include/core/SkTypes.h"

            
            #include "include/private/gpu/ganesh/GrTypesPriv.h"

            
            #include "src/gpu/ganesh/geometry/GrQuad.h"

            
            #include "src/gpu/ganesh/geometry/GrQuadUtils.h"

            
            #include "tests/Test.h"


            #define ASSERT(cond) REPORTER_ASSERT(r, cond)

            
            #define ASSERTF(cond, ...) REPORTER_ASSERT(r, cond, __VA_ARGS__)

            
            #define TEST(name) DEF_TEST(GrQuadCrop##name, r)

            
            #define ASSERT_NEARLY_EQUAL(expected, actual) \

            
                ASSERTF(SkScalarNearlyEqual(expected, actual), "expected: %f, actual: %f", \

            
                        expected, actual)


            // Make the base rect contain the origin and have unique edge values so that each transform

            
            // produces a different axis-aligned rectangle.

            
            static const SkRect kDrawRect = SkRect::MakeLTRB(-5.f, -6.f, 10.f, 11.f);


            static void run_crop_axis_aligned_test(skiatest::Reporter* r, const SkRect& clipRect, GrAA clipAA,

            
                                                   const SkMatrix& viewMatrix, const SkMatrix* localMatrix) {

            
                // Should use run_crop_fully_covers_test for non-rect matrices

            
                SkASSERT(viewMatrix.rectStaysRect());


                DrawQuad quad = {GrQuad::MakeFromRect(kDrawRect, viewMatrix),

            
                                 GrQuad::MakeFromRect(kDrawRect, localMatrix ? *localMatrix : SkMatrix::I()),

            
                                 clipAA == GrAA::kYes ? GrQuadAAFlags::kNone : GrQuadAAFlags::kAll};


                bool exact = GrQuadUtils::CropToRect(clipRect, clipAA, &quad, /* calc. locals */ !!localMatrix);

            
                ASSERTF(exact, "Expected exact crop");

            
                ASSERTF(quad.fDevice.quadType() == GrQuad::Type::kAxisAligned,

            
                        "Expected quad to remain axis-aligned");


                // Since we remained a rectangle, the bounds will exactly match the coordinates

            
                SkRect expectedBounds = viewMatrix.mapRect(kDrawRect);

            
                SkAssertResult(expectedBounds.intersect(clipRect));


                SkRect actualBounds = quad.fDevice.bounds();

            
                ASSERT_NEARLY_EQUAL(expectedBounds.fLeft, actualBounds.fLeft);

            
                ASSERT_NEARLY_EQUAL(expectedBounds.fTop, actualBounds.fTop);

            
                ASSERT_NEARLY_EQUAL(expectedBounds.fRight, actualBounds.fRight);

            
                ASSERT_NEARLY_EQUAL(expectedBounds.fBottom, actualBounds.fBottom);


                // Confirm that local coordinates match up with clipped edges and the transform

            
                SkMatrix invViewMatrix;

            
                SkAssertResult(viewMatrix.invert(&invViewMatrix));


                if (localMatrix) {

            
                    SkMatrix toLocal = SkMatrix::Concat(*localMatrix, invViewMatrix);


                    for (int p = 0; p < 4; ++p) {

            
                        SkPoint expectedPoint = quad.fDevice.point(p);

            
                        toLocal.mapPoints(&expectedPoint, 1);

            
                        SkPoint actualPoint = quad.fLocal.point(p);


                        ASSERT_NEARLY_EQUAL(expectedPoint.fX, actualPoint.fX);

            
                        ASSERT_NEARLY_EQUAL(expectedPoint.fY, actualPoint.fY);

            
                    }

            
                }


                // Confirm that the edge flags match, by mapping clip rect to drawRect space and

            
                // comparing to the original draw rect edges

            
                SkRect drawClip = invViewMatrix.mapRect(clipRect);

            
                if (drawClip.fLeft > kDrawRect.fLeft) {

            
                    if (clipAA == GrAA::kYes) {

            
                        ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kLeft, "Expected left edge AA set");

            
                    } else {

            
                        ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kLeft), "Expected left edge AA unset");

            
                    }

            
                }

            
                if (drawClip.fRight < kDrawRect.fRight) {

            
                    if (clipAA == GrAA::kYes) {

            
                        ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kRight, "Expected right edge AA set");

            
                    } else {

            
                        ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kRight),  "Expected right edge AA unset");

            
                    }

            
                }

            
                if (drawClip.fTop > kDrawRect.fTop) {

            
                    if (clipAA == GrAA::kYes) {

            
                        ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kTop, "Expected top edge AA set");

            
                    } else {

            
                        ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kTop), "Expected top edge AA unset");

            
                    }

            
                }

            
                if (drawClip.fBottom < kDrawRect.fBottom) {

            
                    if (clipAA == GrAA::kYes) {

            
                        ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kBottom, "Expected bottom edge AA set");

            
                    } else {

            
                        ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kBottom), "Expected bottom edge AA unset");

            
                    }

            
                }

            
            }


            static void run_crop_fully_covered_test(skiatest::Reporter* r, GrAA clipAA,

            
                                                    const SkMatrix& viewMatrix, const SkMatrix* localMatrix) {

            
                // Should use run_crop_axis_aligned for rect transforms since that verifies more behavior

            
                SkASSERT(!viewMatrix.rectStaysRect());


                // Test what happens when the geometry fully covers the crop rect. Given a fixed crop,

            
                // use the provided view matrix to derive the "input" geometry that we know covers the crop.

            
                SkMatrix invViewMatrix;

            
                SkAssertResult(viewMatrix.invert(&invViewMatrix));


                SkRect containsCrop = kDrawRect; // Use kDrawRect as the crop rect for this test

            
                containsCrop.outset(10.f, 10.f);

            
                SkRect drawRect = invViewMatrix.mapRect(containsCrop);


                DrawQuad quad = {GrQuad::MakeFromRect(drawRect, viewMatrix),

            
                                 GrQuad::MakeFromRect(drawRect, localMatrix ? *localMatrix : SkMatrix::I()),

            
                                 clipAA == GrAA::kYes ? GrQuadAAFlags::kNone : GrQuadAAFlags::kAll};


                if (localMatrix) {

            
                    DrawQuad originalQuad = quad;


                    bool exact = GrQuadUtils::CropToRect(kDrawRect, clipAA, &quad);

            
                    // Currently non-rect matrices don't know how to update local coordinates, so the crop

            
                    // doesn't know how to restrict itself and should leave the inputs unmodified

            
                    ASSERTF(!exact, "Expected crop to be not exact");

            
                    ASSERTF(quad.fEdgeFlags == originalQuad.fEdgeFlags,

            
                            "Expected edge flags not to be modified");


                    for (int i = 0; i < 4; ++i) {

            
                        ASSERT_NEARLY_EQUAL(originalQuad.fDevice.x(i), quad.fDevice.x(i));

            
                        ASSERT_NEARLY_EQUAL(originalQuad.fDevice.y(i), quad.fDevice.y(i));

            
                        ASSERT_NEARLY_EQUAL(originalQuad.fDevice.w(i), quad.fDevice.w(i));


                        ASSERT_NEARLY_EQUAL(originalQuad.fLocal.x(i), quad.fLocal.x(i));

            
                        ASSERT_NEARLY_EQUAL(originalQuad.fLocal.y(i), quad.fLocal.y(i));

            
                        ASSERT_NEARLY_EQUAL(originalQuad.fLocal.w(i), quad.fLocal.w(i));

            
                    }

            
                } else {

            
                    // Since no local coordinates were provided, and the input draw geometry is known to

            
                    // fully cover the crop rect, the quad should be updated to match cropRect exactly,

            
                    // unless it's perspective in which case we don't do anything since the code isn't

            
                    // numerically robust enough.

            
                    DrawQuad originalQuad = quad;

            
                    bool exact = GrQuadUtils::CropToRect(kDrawRect, clipAA, &quad, /* calc. local */ false);

            
                    if (originalQuad.fDevice.quadType() == GrQuad::Type::kPerspective) {

            
                        ASSERTF(!exact, "Expected no change for perspective");

            
                        for (int i = 0; i < 4; ++i) {

            
                            ASSERTF(originalQuad.fDevice.x(i) == quad.fDevice.x(i));

            
                            ASSERTF(originalQuad.fDevice.y(i) == quad.fDevice.y(i));

            
                            ASSERTF(originalQuad.fDevice.w(i) == quad.fDevice.w(i));

            
                        }

            
                        return;

            
                    }


                    ASSERTF(exact, "Expected crop to be exact");

            
                    GrQuadAAFlags expectedFlags = clipAA == GrAA::kYes ? GrQuadAAFlags::kAll

            
                                                                       : GrQuadAAFlags::kNone;

            
                    ASSERTF(expectedFlags == quad.fEdgeFlags,

            
                            "Expected edge flags do not match clip AA setting");

            
                    ASSERTF(quad.fDevice.quadType() == GrQuad::Type::kAxisAligned, "Unexpected quad type");


                    ASSERT_NEARLY_EQUAL(kDrawRect.fLeft, quad.fDevice.x(0));

            
                    ASSERT_NEARLY_EQUAL(kDrawRect.fTop, quad.fDevice.y(0));

            
                    ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(0));


                    ASSERT_NEARLY_EQUAL(kDrawRect.fLeft, quad.fDevice.x(1));

            
                    ASSERT_NEARLY_EQUAL(kDrawRect.fBottom, quad.fDevice.y(1));

            
                    ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(1));


                    ASSERT_NEARLY_EQUAL(kDrawRect.fRight, quad.fDevice.x(2));

            
                    ASSERT_NEARLY_EQUAL(kDrawRect.fTop, quad.fDevice.y(2));

            
                    ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(2));


                    ASSERT_NEARLY_EQUAL(kDrawRect.fRight, quad.fDevice.x(3));

            
                    ASSERT_NEARLY_EQUAL(kDrawRect.fBottom, quad.fDevice.y(3));

            
                    ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(3));

            
                }

            
            }


            static void test_axis_aligned_all_clips(skiatest::Reporter* r, const SkMatrix& viewMatrix,

            
                                                    const SkMatrix* localMatrix) {

            
                static const float kInsideEdge = SkScalarAbs(kDrawRect.fLeft) - 1.f;

            
                static const float kOutsideEdge = SkScalarAbs(kDrawRect.fBottom) + 1.f;

            
                static const float kIntersectEdge = SkScalarAbs(kDrawRect.fTop) + 1.f;


                static const SkRect kInsideClipRect = SkRect::MakeLTRB(-kInsideEdge, -kInsideEdge,

            
                                                                       kInsideEdge, kInsideEdge);

            
                static const SkRect kContainsClipRect = SkRect::MakeLTRB(-kOutsideEdge, -kOutsideEdge,

            
                                                                         kOutsideEdge, kOutsideEdge);

            
                static const SkRect kXYAxesClipRect = SkRect::MakeLTRB(-kIntersectEdge, -kIntersectEdge,

            
                                                                       kIntersectEdge, kIntersectEdge);

            
                static const SkRect kXAxisClipRect = SkRect::MakeLTRB(-kIntersectEdge, -kOutsideEdge,

            
                                                                      kIntersectEdge, kOutsideEdge);

            
                static const SkRect kYAxisClipRect = SkRect::MakeLTRB(-kOutsideEdge, -kIntersectEdge,

            
                                                                      kOutsideEdge, kIntersectEdge);


                run_crop_axis_aligned_test(r, kInsideClipRect, GrAA::kNo, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kContainsClipRect, GrAA::kNo, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kXYAxesClipRect, GrAA::kNo, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kXAxisClipRect, GrAA::kNo, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kYAxisClipRect, GrAA::kNo, viewMatrix, localMatrix);


                run_crop_axis_aligned_test(r, kInsideClipRect, GrAA::kYes, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kContainsClipRect, GrAA::kYes, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kXYAxesClipRect, GrAA::kYes, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kXAxisClipRect, GrAA::kYes, viewMatrix, localMatrix);

            
                run_crop_axis_aligned_test(r, kYAxisClipRect, GrAA::kYes, viewMatrix, localMatrix);

            
            }


            static void test_axis_aligned(skiatest::Reporter* r, const SkMatrix& viewMatrix) {

            
                test_axis_aligned_all_clips(r, viewMatrix, nullptr);


                SkMatrix normalized = SkMatrix::RectToRect(kDrawRect, SkRect::MakeWH(1.f, 1.f));

            
                test_axis_aligned_all_clips(r, viewMatrix, &normalized);


                SkMatrix rotated;

            
                rotated.setRotate(45.f);

            
                test_axis_aligned_all_clips(r, viewMatrix, &rotated);


                SkMatrix perspective;

            
                perspective.setPerspY(0.001f);

            
                perspective.setSkewX(8.f / 25.f);

            
                test_axis_aligned_all_clips(r, viewMatrix, &perspective);

            
            }


            static void test_crop_fully_covered(skiatest::Reporter* r, const SkMatrix& viewMatrix) {

            
                run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, nullptr);

            
                run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, nullptr);


                SkMatrix normalized = SkMatrix::RectToRect(kDrawRect, SkRect::MakeWH(1.f, 1.f));

            
                run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &normalized);

            
                run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &normalized);


                SkMatrix rotated;

            
                rotated.setRotate(45.f);

            
                run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &rotated);

            
                run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &rotated);


                SkMatrix perspective;

            
                perspective.setPerspY(0.001f);

            
                perspective.setSkewX(8.f / 25.f);

            
                run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &perspective);

            
                run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &perspective);

            
            }


            TEST(AxisAligned) {

            
                test_axis_aligned(r, SkMatrix::I());

            
                test_axis_aligned(r, SkMatrix::Scale(-1.f, 1.f));

            
                test_axis_aligned(r, SkMatrix::Scale(1.f, -1.f));


                SkMatrix rotation;

            
                rotation.setRotate(90.f);

            
                test_axis_aligned(r, rotation);

            
                rotation.setRotate(180.f);

            
                test_axis_aligned(r, rotation);

            
                rotation.setRotate(270.f);

            
                test_axis_aligned(r, rotation);

            
            }


            TEST(FullyCovered) {

            
                SkMatrix rotation;

            
                rotation.setRotate(34.f);

            
                test_crop_fully_covered(r, rotation);


                SkMatrix skew;

            
                skew.setSkewX(0.3f);

            
                skew.setSkewY(0.04f);

            
                test_crop_fully_covered(r, skew);


                SkMatrix perspective;

            
                perspective.setPerspX(0.001f);

            
                perspective.setSkewY(8.f / 25.f);

            
                test_crop_fully_covered(r, perspective);

            
            }
	/*
	* Copyright 2019 Google LLC
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "include/core/SkMatrix.h"
	#include "include/core/SkPoint.h"
	#include "include/core/SkRect.h"
	#include "include/core/SkScalar.h"
	#include "include/core/SkTypes.h"
	#include "include/private/gpu/ganesh/GrTypesPriv.h"
	#include "src/gpu/ganesh/geometry/GrQuad.h"
	#include "src/gpu/ganesh/geometry/GrQuadUtils.h"
	#include "tests/Test.h"

	#define ASSERT(cond) REPORTER_ASSERT(r, cond)
	#define ASSERTF(cond, ...) REPORTER_ASSERT(r, cond, __VA_ARGS__)
	#define TEST(name) DEF_TEST(GrQuadCrop##name, r)
	#define ASSERT_NEARLY_EQUAL(expected, actual) \
	ASSERTF(SkScalarNearlyEqual(expected, actual), "expected: %f, actual: %f", \
	expected, actual)

	// Make the base rect contain the origin and have unique edge values so that each transform
	// produces a different axis-aligned rectangle.
	static const SkRect kDrawRect = SkRect::MakeLTRB(-5.f, -6.f, 10.f, 11.f);

	static void run_crop_axis_aligned_test(skiatest::Reporter* r, const SkRect& clipRect, GrAA clipAA,
	const SkMatrix& viewMatrix, const SkMatrix* localMatrix) {
	// Should use run_crop_fully_covers_test for non-rect matrices
	SkASSERT(viewMatrix.rectStaysRect());

	DrawQuad quad = {GrQuad::MakeFromRect(kDrawRect, viewMatrix),
	GrQuad::MakeFromRect(kDrawRect, localMatrix ? *localMatrix : SkMatrix::I()),
	clipAA == GrAA::kYes ? GrQuadAAFlags::kNone : GrQuadAAFlags::kAll};

	bool exact = GrQuadUtils::CropToRect(clipRect, clipAA, &quad, /* calc. locals */ !!localMatrix);
	ASSERTF(exact, "Expected exact crop");
	ASSERTF(quad.fDevice.quadType() == GrQuad::Type::kAxisAligned,
	"Expected quad to remain axis-aligned");

	// Since we remained a rectangle, the bounds will exactly match the coordinates
	SkRect expectedBounds = viewMatrix.mapRect(kDrawRect);
	SkAssertResult(expectedBounds.intersect(clipRect));

	SkRect actualBounds = quad.fDevice.bounds();
	ASSERT_NEARLY_EQUAL(expectedBounds.fLeft, actualBounds.fLeft);
	ASSERT_NEARLY_EQUAL(expectedBounds.fTop, actualBounds.fTop);
	ASSERT_NEARLY_EQUAL(expectedBounds.fRight, actualBounds.fRight);
	ASSERT_NEARLY_EQUAL(expectedBounds.fBottom, actualBounds.fBottom);

	// Confirm that local coordinates match up with clipped edges and the transform
	SkMatrix invViewMatrix;
	SkAssertResult(viewMatrix.invert(&invViewMatrix));

	if (localMatrix) {
	SkMatrix toLocal = SkMatrix::Concat(*localMatrix, invViewMatrix);

	for (int p = 0; p < 4; ++p) {
	SkPoint expectedPoint = quad.fDevice.point(p);
	toLocal.mapPoints(&expectedPoint, 1);
	SkPoint actualPoint = quad.fLocal.point(p);

	ASSERT_NEARLY_EQUAL(expectedPoint.fX, actualPoint.fX);
	ASSERT_NEARLY_EQUAL(expectedPoint.fY, actualPoint.fY);
	}
	}

	// Confirm that the edge flags match, by mapping clip rect to drawRect space and
	// comparing to the original draw rect edges
	SkRect drawClip = invViewMatrix.mapRect(clipRect);
	if (drawClip.fLeft > kDrawRect.fLeft) {
	if (clipAA == GrAA::kYes) {
	ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kLeft, "Expected left edge AA set");
	} else {
	ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kLeft), "Expected left edge AA unset");
	}
	}
	if (drawClip.fRight < kDrawRect.fRight) {
	if (clipAA == GrAA::kYes) {
	ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kRight, "Expected right edge AA set");
	} else {
	ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kRight), "Expected right edge AA unset");
	}
	}
	if (drawClip.fTop > kDrawRect.fTop) {
	if (clipAA == GrAA::kYes) {
	ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kTop, "Expected top edge AA set");
	} else {
	ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kTop), "Expected top edge AA unset");
	}
	}
	if (drawClip.fBottom < kDrawRect.fBottom) {
	if (clipAA == GrAA::kYes) {
	ASSERTF(quad.fEdgeFlags & GrQuadAAFlags::kBottom, "Expected bottom edge AA set");
	} else {
	ASSERTF(!(quad.fEdgeFlags & GrQuadAAFlags::kBottom), "Expected bottom edge AA unset");
	}
	}
	}

	static void run_crop_fully_covered_test(skiatest::Reporter* r, GrAA clipAA,
	const SkMatrix& viewMatrix, const SkMatrix* localMatrix) {
	// Should use run_crop_axis_aligned for rect transforms since that verifies more behavior
	SkASSERT(!viewMatrix.rectStaysRect());

	// Test what happens when the geometry fully covers the crop rect. Given a fixed crop,
	// use the provided view matrix to derive the "input" geometry that we know covers the crop.
	SkMatrix invViewMatrix;
	SkAssertResult(viewMatrix.invert(&invViewMatrix));

	SkRect containsCrop = kDrawRect; // Use kDrawRect as the crop rect for this test
	containsCrop.outset(10.f, 10.f);
	SkRect drawRect = invViewMatrix.mapRect(containsCrop);

	DrawQuad quad = {GrQuad::MakeFromRect(drawRect, viewMatrix),
	GrQuad::MakeFromRect(drawRect, localMatrix ? *localMatrix : SkMatrix::I()),
	clipAA == GrAA::kYes ? GrQuadAAFlags::kNone : GrQuadAAFlags::kAll};

	if (localMatrix) {
	DrawQuad originalQuad = quad;

	bool exact = GrQuadUtils::CropToRect(kDrawRect, clipAA, &quad);
	// Currently non-rect matrices don't know how to update local coordinates, so the crop
	// doesn't know how to restrict itself and should leave the inputs unmodified
	ASSERTF(!exact, "Expected crop to be not exact");
	ASSERTF(quad.fEdgeFlags == originalQuad.fEdgeFlags,
	"Expected edge flags not to be modified");

	for (int i = 0; i < 4; ++i) {
	ASSERT_NEARLY_EQUAL(originalQuad.fDevice.x(i), quad.fDevice.x(i));
	ASSERT_NEARLY_EQUAL(originalQuad.fDevice.y(i), quad.fDevice.y(i));
	ASSERT_NEARLY_EQUAL(originalQuad.fDevice.w(i), quad.fDevice.w(i));

	ASSERT_NEARLY_EQUAL(originalQuad.fLocal.x(i), quad.fLocal.x(i));
	ASSERT_NEARLY_EQUAL(originalQuad.fLocal.y(i), quad.fLocal.y(i));
	ASSERT_NEARLY_EQUAL(originalQuad.fLocal.w(i), quad.fLocal.w(i));
	}
	} else {
	// Since no local coordinates were provided, and the input draw geometry is known to
	// fully cover the crop rect, the quad should be updated to match cropRect exactly,
	// unless it's perspective in which case we don't do anything since the code isn't
	// numerically robust enough.
	DrawQuad originalQuad = quad;
	bool exact = GrQuadUtils::CropToRect(kDrawRect, clipAA, &quad, /* calc. local */ false);
	if (originalQuad.fDevice.quadType() == GrQuad::Type::kPerspective) {
	ASSERTF(!exact, "Expected no change for perspective");
	for (int i = 0; i < 4; ++i) {
	ASSERTF(originalQuad.fDevice.x(i) == quad.fDevice.x(i));
	ASSERTF(originalQuad.fDevice.y(i) == quad.fDevice.y(i));
	ASSERTF(originalQuad.fDevice.w(i) == quad.fDevice.w(i));
	}
	return;
	}

	ASSERTF(exact, "Expected crop to be exact");
	GrQuadAAFlags expectedFlags = clipAA == GrAA::kYes ? GrQuadAAFlags::kAll
	: GrQuadAAFlags::kNone;
	ASSERTF(expectedFlags == quad.fEdgeFlags,
	"Expected edge flags do not match clip AA setting");
	ASSERTF(quad.fDevice.quadType() == GrQuad::Type::kAxisAligned, "Unexpected quad type");

	ASSERT_NEARLY_EQUAL(kDrawRect.fLeft, quad.fDevice.x(0));
	ASSERT_NEARLY_EQUAL(kDrawRect.fTop, quad.fDevice.y(0));
	ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(0));

	ASSERT_NEARLY_EQUAL(kDrawRect.fLeft, quad.fDevice.x(1));
	ASSERT_NEARLY_EQUAL(kDrawRect.fBottom, quad.fDevice.y(1));
	ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(1));

	ASSERT_NEARLY_EQUAL(kDrawRect.fRight, quad.fDevice.x(2));
	ASSERT_NEARLY_EQUAL(kDrawRect.fTop, quad.fDevice.y(2));
	ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(2));

	ASSERT_NEARLY_EQUAL(kDrawRect.fRight, quad.fDevice.x(3));
	ASSERT_NEARLY_EQUAL(kDrawRect.fBottom, quad.fDevice.y(3));
	ASSERT_NEARLY_EQUAL(1.f, quad.fDevice.w(3));
	}
	}

	static void test_axis_aligned_all_clips(skiatest::Reporter* r, const SkMatrix& viewMatrix,
	const SkMatrix* localMatrix) {
	static const float kInsideEdge = SkScalarAbs(kDrawRect.fLeft) - 1.f;
	static const float kOutsideEdge = SkScalarAbs(kDrawRect.fBottom) + 1.f;
	static const float kIntersectEdge = SkScalarAbs(kDrawRect.fTop) + 1.f;

	static const SkRect kInsideClipRect = SkRect::MakeLTRB(-kInsideEdge, -kInsideEdge,
	kInsideEdge, kInsideEdge);
	static const SkRect kContainsClipRect = SkRect::MakeLTRB(-kOutsideEdge, -kOutsideEdge,
	kOutsideEdge, kOutsideEdge);
	static const SkRect kXYAxesClipRect = SkRect::MakeLTRB(-kIntersectEdge, -kIntersectEdge,
	kIntersectEdge, kIntersectEdge);
	static const SkRect kXAxisClipRect = SkRect::MakeLTRB(-kIntersectEdge, -kOutsideEdge,
	kIntersectEdge, kOutsideEdge);
	static const SkRect kYAxisClipRect = SkRect::MakeLTRB(-kOutsideEdge, -kIntersectEdge,
	kOutsideEdge, kIntersectEdge);

	run_crop_axis_aligned_test(r, kInsideClipRect, GrAA::kNo, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kContainsClipRect, GrAA::kNo, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kXYAxesClipRect, GrAA::kNo, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kXAxisClipRect, GrAA::kNo, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kYAxisClipRect, GrAA::kNo, viewMatrix, localMatrix);

	run_crop_axis_aligned_test(r, kInsideClipRect, GrAA::kYes, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kContainsClipRect, GrAA::kYes, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kXYAxesClipRect, GrAA::kYes, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kXAxisClipRect, GrAA::kYes, viewMatrix, localMatrix);
	run_crop_axis_aligned_test(r, kYAxisClipRect, GrAA::kYes, viewMatrix, localMatrix);
	}

	static void test_axis_aligned(skiatest::Reporter* r, const SkMatrix& viewMatrix) {
	test_axis_aligned_all_clips(r, viewMatrix, nullptr);

	SkMatrix normalized = SkMatrix::RectToRect(kDrawRect, SkRect::MakeWH(1.f, 1.f));
	test_axis_aligned_all_clips(r, viewMatrix, &normalized);

	SkMatrix rotated;
	rotated.setRotate(45.f);
	test_axis_aligned_all_clips(r, viewMatrix, &rotated);

	SkMatrix perspective;
	perspective.setPerspY(0.001f);
	perspective.setSkewX(8.f / 25.f);
	test_axis_aligned_all_clips(r, viewMatrix, &perspective);
	}

	static void test_crop_fully_covered(skiatest::Reporter* r, const SkMatrix& viewMatrix) {
	run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, nullptr);
	run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, nullptr);

	SkMatrix normalized = SkMatrix::RectToRect(kDrawRect, SkRect::MakeWH(1.f, 1.f));
	run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &normalized);
	run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &normalized);

	SkMatrix rotated;
	rotated.setRotate(45.f);
	run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &rotated);
	run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &rotated);

	SkMatrix perspective;
	perspective.setPerspY(0.001f);
	perspective.setSkewX(8.f / 25.f);
	run_crop_fully_covered_test(r, GrAA::kNo, viewMatrix, &perspective);
	run_crop_fully_covered_test(r, GrAA::kYes, viewMatrix, &perspective);
	}

	TEST(AxisAligned) {
	test_axis_aligned(r, SkMatrix::I());
	test_axis_aligned(r, SkMatrix::Scale(-1.f, 1.f));
	test_axis_aligned(r, SkMatrix::Scale(1.f, -1.f));

	SkMatrix rotation;
	rotation.setRotate(90.f);
	test_axis_aligned(r, rotation);
	rotation.setRotate(180.f);
	test_axis_aligned(r, rotation);
	rotation.setRotate(270.f);
	test_axis_aligned(r, rotation);
	}

	TEST(FullyCovered) {
	SkMatrix rotation;
	rotation.setRotate(34.f);
	test_crop_fully_covered(r, rotation);

	SkMatrix skew;
	skew.setSkewX(0.3f);
	skew.setSkewY(0.04f);
	test_crop_fully_covered(r, skew);

	SkMatrix perspective;
	perspective.setPerspX(0.001f);
	perspective.setSkewY(8.f / 25.f);
	test_crop_fully_covered(r, perspective);
	}