skiagm::MatrixConvolutionGM Class Reference

Inheritance diagram for skiagm::MatrixConvolutionGM:

Public Member Functions
	MatrixConvolutionGM (SkColor colorOne, SkColor colorTwo, KernelFixture kernelFixture, const char *nameSuffix)
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	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
void	makeBitmap ()
SkISize	getISize () override
sk_sp< SkImageFilter >	makeFilter (const SkIPoint &kernelOffset, SkTileMode tileMode, bool convolveAlpha)
void	draw (SkCanvas *canvas, int x, int y, const SkIPoint &kernelOffset, SkTileMode tileMode, bool convolveAlpha, const SkIRect *cropRect=nullptr)
void	onOnceBeforeDraw () override
void	onDraw (SkCanvas *canvas) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
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

Definition at line 38 of file matrixconvolution.cpp.

Constructor & Destructor Documentation

MatrixConvolutionGM()

skiagm::MatrixConvolutionGM::MatrixConvolutionGM ( SkColor  colorOne, SkColor  colorTwo, KernelFixture  kernelFixture, const char *  nameSuffix  )

inline

Definition at line 40 of file matrixconvolution.cpp.

            : fNameSuffix(nameSuffix),
              fKernelFixture(kernelFixture) {
        this->setBGColor(0x00000000);
        fColors[0] = colorOne;
        fColors[1] = colorTwo;
    }

Member Function Documentation

draw()

void skiagm::MatrixConvolutionGM::draw ( SkCanvas *  canvas, int  x, int  y, const SkIPoint &  kernelOffset, SkTileMode  tileMode, bool  convolveAlpha, const SkIRect *  cropRect = nullptr  )

inlineprotected

Definition at line 97 of file matrixconvolution.cpp.

                                                 {
        SkPaint paint;
        auto filter = this->makeFilter(kernelOffset, tileMode, convolveAlpha);
        if (cropRect) {
            filter = SkImageFilters::Crop(SkRect::Make(*cropRect), std::move(filter));
        }
        paint.setImageFilter(std::move(filter));
        canvas->save();
        canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
        canvas->drawImage(fImage, 0, 0, {}, &paint);
        canvas->restore();
    }

getISize()

SkISize skiagm::MatrixConvolutionGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 66 of file matrixconvolution.cpp.

{ return SkISize::Make(500, 300); }

getName()

SkString skiagm::MatrixConvolutionGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 49 of file matrixconvolution.cpp.

{ return SkStringPrintf("matrixconvolution%s", fNameSuffix); }

makeBitmap()

void skiagm::MatrixConvolutionGM::makeBitmap ( )

inlineprotected

Definition at line 51 of file matrixconvolution.cpp.

                      {
        // Draw our bitmap in N32, so legacy devices get "premul" values they understand
        auto surf = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(80, 80));
        SkPaint paint;
        paint.setColor(0xFFFFFFFF);
        SkPoint pts[2] = { {0, 0},
                           {0, 80.0f} };
        SkScalar pos[2] = { 0, 80.0f };
        paint.setShader(SkGradientShader::MakeLinear(
            pts, fColors, pos, 2, SkTileMode::kClamp));
        SkFont font(ToolUtils::DefaultPortableTypeface(), 180.0f);
        surf->getCanvas()->drawString("e", -10.0f, 80.0f, font, paint);
        fImage = surf->makeImageSnapshot();
    }

makeFilter()

sk_sp< SkImageFilter > skiagm::MatrixConvolutionGM::makeFilter ( const SkIPoint &  kernelOffset, SkTileMode  tileMode, bool  convolveAlpha  )

inlineprotected

Definition at line 68 of file matrixconvolution.cpp.

                                                        {
        // Must provide a cropping geometry in order for 'tileMode' to be well defined.
        SkIRect tileBoundary = fImage->bounds();
        switch (fKernelFixture) {
            case kBasic_KernelFixture: {
                // All 1s except center value, which is -7 (sum of 1).
                std::vector<SkScalar> kernel(9, SkIntToScalar(1));
                kernel[4] = SkIntToScalar(-7);
                return SkImageFilters::MatrixConvolution(
                        {3,3}, kernel.data(), /* gain */ 0.3f, /* bias */ SkIntToScalar(100),
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            case kLarge_KernelFixture: {
                // This ensures the texture fallback path will be taken
                static_assert(49 > skgpu::kMaxBlurSamples);
                // All 1s except center value, which is -47 (sum of 1).
                std::vector<SkScalar> kernel(49, SkIntToScalar(1));
                kernel[24] = SkIntToScalar(-47);
                return SkImageFilters::MatrixConvolution(
                        {7,7}, kernel.data(), /* gain */ 0.3f, /* bias */ SkIntToScalar(100),
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            default:
                return nullptr;
        }
    }

onDraw()

void skiagm::MatrixConvolutionGM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 116 of file matrixconvolution.cpp.

                                           {
        canvas->clear(SK_ColorBLACK);
        SkIPoint kernelOffset = SkIPoint::Make(1, 0);
        for (int x = 10; x < 310; x += 100) {
            this->draw(canvas, x, 10, kernelOffset, SkTileMode::kClamp, true);
            this->draw(canvas, x, 110, kernelOffset, SkTileMode::kDecal, true);
            this->draw(canvas, x, 210, kernelOffset, SkTileMode::kRepeat, true);
            kernelOffset.fY++;
        }
        kernelOffset.fY = 1;
        SkIRect smallRect = SkIRect::MakeXYWH(10, 5, 60, 60);
        this->draw(canvas, 310, 10, kernelOffset, SkTileMode::kClamp, true, &smallRect);
        this->draw(canvas, 310, 110, kernelOffset, SkTileMode::kDecal, true, &smallRect);
        this->draw(canvas, 310, 210, kernelOffset, SkTileMode::kRepeat, true, &smallRect);
 
        this->draw(canvas, 410, 10, kernelOffset, SkTileMode::kClamp, false);
        this->draw(canvas, 410, 110, kernelOffset, SkTileMode::kDecal, false);
        this->draw(canvas, 410, 210, kernelOffset, SkTileMode::kRepeat, false);
    }

onOnceBeforeDraw()

void skiagm::MatrixConvolutionGM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 112 of file matrixconvolution.cpp.

                                     {
        this->makeBitmap();
    }

---

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

• third_party/skia/gm/matrixconvolution.cpp