SrcRectConstraintGM Class Reference

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 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	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 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.

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

getName()

SkString SrcRectConstraintGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 130 of file bleed.cpp.

{ 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