Inheritance diagram for SrcRectConstraintGM:

Public Member Functions
	SrcRectConstraintGM (const char *shortName, SkCanvas::SrcRectConstraint constraint, bool manual)

Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)

virtual	~GM ()

void	setMode (Mode mode)

Mode	getMode () const

DrawResult	gpuSetup (SkCanvas , SkString errorMsg, GraphiteTestContext *=nullptr)

void	gpuTeardown ()

void	onceBeforeDraw ()

DrawResult	draw (SkCanvas *canvas)

DrawResult	draw (SkCanvas , SkString errorMsg)

void	drawBackground (SkCanvas *)

DrawResult	drawContent (SkCanvas *canvas)

DrawResult	drawContent (SkCanvas , SkString errorMsg)

virtual SkISize	getISize ()=0

virtual SkString	getName () const =0

virtual bool	runAsBench () const

SkScalar	width ()

SkScalar	height ()

SkColor	getBGColor () const

void	setBGColor (SkColor)

void	drawSizeBounds (SkCanvas *, SkColor)

bool	animate (double)

virtual bool	onChar (SkUnichar)

bool	getControls (SkMetaData *controls)

void	setControls (const SkMetaData &controls)

virtual void	modifyGrContextOptions (GrContextOptions *)

virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const

virtual bool	isBazelOnly () const

virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
SkString	getName () const override

SkISize	getISize () override

void	drawImage (SkCanvas canvas, sk_sp< SkImage > image, SkRect srcRect, SkRect dstRect, const SkSamplingOptions &sampling, SkPaint paint)

void	drawCase1 (SkCanvas *canvas, int transX, int transY, bool aa, const SkSamplingOptions &sampling)

void	drawCase2 (SkCanvas *canvas, int transX, int transY, bool aa, const SkSamplingOptions &sampling)

void	drawCase3 (SkCanvas *canvas, int transX, int transY, bool aa, const SkSamplingOptions &sampling)

void	drawCase4 (SkCanvas *canvas, int transX, int transY, bool aa, const SkSamplingOptions &sampling)

void	drawCase5 (SkCanvas *canvas, int transX, int transY, bool aa, const SkSamplingOptions &sampling)

void	onDraw (SkCanvas *canvas) override

void	modifyGrContextOptions (GrContextOptions *options) override

Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas , SkString , GraphiteTestContext *)

virtual void	onGpuTeardown ()

virtual void	onOnceBeforeDraw ()

virtual DrawResult	onDraw (SkCanvas , SkString errorMsg)

virtual void	onDraw (SkCanvas *)

virtual bool	onAnimate (double)

virtual bool	onGetControls (SkMetaData *)

virtual void	onSetControls (const SkMetaData &)

GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }

using	DrawResult = skiagm::DrawResult

using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

These GMs exercise the behavior of the drawImageRect and its SrcRectConstraint parameter. They tests various matrices, filter qualities, and interaction with mask filters. They also exercise the tiling image draws of SkGpuDevice by overriding the maximum texture size of the GrContext.

Definition at line 118 of file bleed.cpp.

Constructor & Destructor Documentation

◆ SrcRectConstraintGM()

SrcRectConstraintGM::SrcRectConstraintGM	(	const char *	shortName,
		SkCanvas::SrcRectConstraint	constraint,
		bool	manual
	)

inline

Definition at line 120 of file bleed.cpp.

        : fShortName(shortName)
        , fConstraint(constraint)
        , fManual(manual) {
        // Make sure GPU SkSurfaces can be created for this GM.
        SkASSERT(this->getISize().width() <= kMaxTextureSize &&
                 this->getISize().height() <= kMaxTextureSize);
    }

Member Function Documentation

◆ drawCase1()

void SrcRectConstraintGM::drawCase1	(	SkCanvas *	canvas,
		int	transX,
		int	transY,
		bool	aa,
		const SkSamplingOptions &	sampling
	)

inlineprotected

Definition at line 144 of file bleed.cpp.

                                                      {
        SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                      SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
        SkPaint paint;
        paint.setColor(SK_ColorBLUE);
        paint.setAntiAlias(aa);
 
        this->drawImage(canvas, fSmallImage, fSmallSrcRect, dst, sampling, &paint);
    }

◆ drawCase2()

void SrcRectConstraintGM::drawCase2	(	SkCanvas *	canvas,
		int	transX,
		int	transY,
		bool	aa,
		const SkSamplingOptions &	sampling
	)

inlineprotected

Definition at line 157 of file bleed.cpp.

                                                      {
        SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                      SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
        SkPaint paint;
        paint.setColor(SK_ColorBLUE);
        paint.setAntiAlias(aa);
 
        this->drawImage(canvas, fBigImage, fBigSrcRect, dst, sampling, &paint);
    }

◆ drawCase3()

void SrcRectConstraintGM::drawCase3	(	SkCanvas *	canvas,
		int	transX,
		int	transY,
		bool	aa,
		const SkSamplingOptions &	sampling
	)

inlineprotected

Definition at line 170 of file bleed.cpp.

                                                      {
        SkRect src = SkRect::MakeXYWH(fBigSrcRect.fLeft,
                                      fBigSrcRect.fTop,
                                      fBigSrcRect.width()/2,
                                      fBigSrcRect.height()/2);
        SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                      SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
        SkPaint paint;
        paint.setColor(SK_ColorBLUE);
        paint.setAntiAlias(aa);
 
        this->drawImage(canvas, fBigImage, src, dst, sampling, &paint);
    }

◆ drawCase4()

void SrcRectConstraintGM::drawCase4	(	SkCanvas *	canvas,
		int	transX,
		int	transY,
		bool	aa,
		const SkSamplingOptions &	sampling
	)

inlineprotected

Definition at line 187 of file bleed.cpp.

                                                      {
        SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                      SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
        SkPaint paint;
        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                   SkBlurMask::ConvertRadiusToSigma(3)));
        paint.setColor(SK_ColorBLUE);
        paint.setAntiAlias(aa);
 
        this->drawImage(canvas, fSmallImage, fSmallSrcRect, dst, sampling, &paint);
    }

◆ drawCase5()

void SrcRectConstraintGM::drawCase5	(	SkCanvas *	canvas,
		int	transX,
		int	transY,
		bool	aa,
		const SkSamplingOptions &	sampling
	)

inlineprotected

Definition at line 202 of file bleed.cpp.

                                                      {
        SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                      SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
        SkPaint paint;
        paint.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle,
                                                   SkBlurMask::ConvertRadiusToSigma(7)));
        paint.setColor(SK_ColorBLUE);
        paint.setAntiAlias(aa);
 
        this->drawImage(canvas, fSmallImage, fSmallSrcRect, dst, sampling, &paint);
    }

◆ drawImage()

void SrcRectConstraintGM::drawImage	(	SkCanvas *	canvas,
		sk_sp< SkImage >	image,
		SkRect	srcRect,
		SkRect	dstRect,
		const SkSamplingOptions &	sampling,
		SkPaint *	paint
	)

inlineprotected

Definition at line 133 of file bleed.cpp.

                                                                      {
        if (fManual) {
            SkTiledImageUtils::DrawImageRect(canvas, image.get(), srcRect, dstRect,
                                             sampling, paint, fConstraint);
        } else {
            canvas->drawImageRect(image.get(), srcRect, dstRect, sampling, paint, fConstraint);
        }
    }

◆ getISize()

SkISize SrcRectConstraintGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 131 of file bleed.cpp.

131{ return SkISize::Make(800, 1000); }

SkISize::Make

static constexpr SkISize Make(int32_t w, int32_t h)

Definition: SkSize.h:20

◆ getName()

SkString SrcRectConstraintGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 130 of file bleed.cpp.

130{ return fShortName; }

◆ modifyGrContextOptions()

void SrcRectConstraintGM::modifyGrContextOptions ( GrContextOptions * options )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 296 of file bleed.cpp.

                                                                    {
        options->fMaxTextureSizeOverride = kMaxTextureSize;
    }

◆ onDraw()

void SrcRectConstraintGM::onDraw ( SkCanvas * canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 216 of file bleed.cpp.

                                           {
        if (!fSmallImage) {
            std::tie(fBigImage, fBigSrcRect) = make_ringed_image(canvas,
                                                                 2*kMaxTextureSize,
                                                                 2*kMaxTextureSize);
            std::tie(fSmallImage, fSmallSrcRect) = make_ringed_image(canvas,
                                                                     kSmallSize, kSmallSize);
        }
 
        canvas->clear(SK_ColorGRAY);
        std::vector<SkMatrix> matrices;
        // Draw with identity
        matrices.push_back(SkMatrix::I());
 
        // Draw with rotation and scale down in x, up in y.
        SkMatrix m;
        constexpr SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
        m.setTranslate(0, kBottom);
        m.preRotate(15.f, 0, kBottom + kBlockSpacing);
        m.preScale(0.71f, 1.22f);
        matrices.push_back(m);
 
        // Align the next set with the middle of the previous in y, translated to the right in x.
        SkPoint corners[] = {{0, 0}, {0, kBottom}, {kWidth, kBottom}, {kWidth, 0}};
        matrices.back().mapPoints(corners, 4);
        m.setTranslate(std::max({corners[0].fX, corners[1].fX, corners[2].fX, corners[3].fX}),
                       (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4);
        m.preScale(0.2f, 0.2f);
        matrices.push_back(m);
 
        const SkSamplingOptions none(SkFilterMode::kNearest);
        const SkSamplingOptions  low(SkFilterMode::kLinear);
        const SkSamplingOptions high(SkCubicResampler::Mitchell());
 
        SkScalar maxX = 0;
        for (bool antiAlias : {false, true}) {
            canvas->save();
            canvas->translate(maxX, 0);
            for (const SkMatrix& matrix : matrices) {
                canvas->save();
                canvas->concat(matrix);
 
                // First draw a column with no filtering
                this->drawCase1(canvas, kCol0X, kRow0Y, antiAlias, none);
                this->drawCase2(canvas, kCol0X, kRow1Y, antiAlias, none);
                this->drawCase3(canvas, kCol0X, kRow2Y, antiAlias, none);
                this->drawCase4(canvas, kCol0X, kRow3Y, antiAlias, none);
                this->drawCase5(canvas, kCol0X, kRow4Y, antiAlias, none);
 
                // Then draw a column with low filtering
                this->drawCase1(canvas, kCol1X, kRow0Y, antiAlias, low);
                this->drawCase2(canvas, kCol1X, kRow1Y, antiAlias, low);
                this->drawCase3(canvas, kCol1X, kRow2Y, antiAlias, low);
                this->drawCase4(canvas, kCol1X, kRow3Y, antiAlias, low);
                this->drawCase5(canvas, kCol1X, kRow4Y, antiAlias, low);
 
                // Then draw a column with high filtering. Skip it if in kStrict mode and MIP
                // mapping will be used. On GPU we allow bleeding at non-base levels because
                // building a new MIP chain for the subset is expensive.
                SkScalar scales[2];
                SkAssertResult(matrix.getMinMaxScales(scales));
                if (fConstraint != SkCanvas::kStrict_SrcRectConstraint || scales[0] >= 1.f) {
                    this->drawCase1(canvas, kCol2X, kRow0Y, antiAlias, high);
                    this->drawCase2(canvas, kCol2X, kRow1Y, antiAlias, high);
                    this->drawCase3(canvas, kCol2X, kRow2Y, antiAlias, high);
                    this->drawCase4(canvas, kCol2X, kRow3Y, antiAlias, high);
                    this->drawCase5(canvas, kCol2X, kRow4Y, antiAlias, high);
                }
 
                SkPoint innerCorners[] = {{0, 0}, {0, kBottom}, {kWidth, kBottom}, {kWidth, 0}};
                matrix.mapPoints(innerCorners, 4);
                SkScalar x = kBlockSize + std::max({innerCorners[0].fX, innerCorners[1].fX,
                                                    innerCorners[2].fX, innerCorners[3].fX});
                maxX = std::max(maxX, x);
                canvas->restore();
            }
            canvas->restore();
        }
    }

The documentation for this class was generated from the following file:

third_party/skia/gm/bleed.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SrcRectConstraintGM()

Member Function Documentation

◆ drawCase1()

◆ drawCase2()

◆ drawCase3()

◆ drawCase4()

◆ drawCase5()

◆ drawImage()

◆ getISize()

◆ getName()

◆ modifyGrContextOptions()

◆ onDraw()