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 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
bool	runAsBench () const override

SkString	getName () const override

void	makeBitmap ()

SkISize	getISize () override

sk_sp< SkImageFilter >	makeFilter (const SkIPoint &kernelOffsetIn, 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 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

Definition at line 40 of file matrixconvolution.cpp.

Constructor & Destructor Documentation

◆ MatrixConvolutionGM()

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

inline

Definition at line 42 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 130 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 70 of file matrixconvolution.cpp.

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

SkISize::Make

static constexpr SkISize Make(int32_t w, int32_t h)

Definition: SkSize.h:20

◆ getName()

SkString skiagm::MatrixConvolutionGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 53 of file matrixconvolution.cpp.

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

SkStringPrintf

SK_API SkString SkStringPrintf(const char *format,...) SK_PRINTF_LIKE(1

Creates a new string and writes into it using a printf()-style format.

◆ makeBitmap()

void skiagm::MatrixConvolutionGM::makeBitmap ( )

inlineprotected

Definition at line 55 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 &	kernelOffsetIn,
		SkTileMode	tileMode,
		bool	convolveAlpha
	)

inlineprotected

Definition at line 72 of file matrixconvolution.cpp.

                                                        {
        // The kernelOffset is specified in a 0..2 coordinate space.
        float normalizedXOffset = kernelOffsetIn.fX / 2.0f;
        float normalizedYOffset = kernelOffsetIn.fY / 2.0f;
        // Must provide a cropping geometry in order for 'tileMode' to be well defined.
        SkIRect tileBoundary = fImage->bounds();
        switch (fKernelFixture) {
            case kBasic_KernelFixture: {
                SkIPoint kernelOffset {SkScalarRoundToInt(2*normalizedXOffset),
                                       SkScalarRoundToInt(2*normalizedYOffset)};
                // 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= */ 100.0f,
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            case kLarge_KernelFixture: {
                SkIPoint kernelOffset {SkScalarRoundToInt(6*normalizedXOffset),
                                       SkScalarRoundToInt(6*normalizedYOffset)};
                // 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= */ 100.0f,
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            case kLarger_KernelFixture: {
                SkIPoint kernelOffset {SkScalarRoundToInt(127*normalizedXOffset), 0};
                // This ensures the texture fallback path will be taken
                static_assert(128 > skgpu::kMaxBlurSamples);
                std::vector<float> kernel(128, 0.0f);
                kernel[64] = 0.5f;
                kernel[65] = -0.5f;
                return SkImageFilters::MatrixConvolution(
                        {128,1}, kernel.data(), /* gain= */ 0.3f, /* bias= */ 100.0f,
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            case kLargest_KernelFixture: {
                SkIPoint kernelOffset {0, SkScalarRoundToInt(254*normalizedYOffset)};
                // This ensures the texture fallback path will be taken
                static_assert(255 > skgpu::kMaxBlurSamples);
                std::vector<float> kernel(255, 0.0f);
                kernel[126] = 0.5f;
                kernel[128] = -0.5f;
                return SkImageFilters::MatrixConvolution(
                        {1,255}, kernel.data(), /* gain= */ 0.3f, /* bias= */ 100.0f,
                        kernelOffset, tileMode, convolveAlpha, nullptr, tileBoundary);
            }
            default:
                return nullptr;
        }
    }

◆ onDraw()

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

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 149 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 145 of file matrixconvolution.cpp.

                                     {
        this->makeBitmap();
    }

◆ runAsBench()

bool skiagm::MatrixConvolutionGM::runAsBench ( ) const

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 51 of file matrixconvolution.cpp.

51{ return true; }

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

third_party/skia/gm/matrixconvolution.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MatrixConvolutionGM()

Member Function Documentation

◆ draw()

◆ getISize()

◆ getName()

◆ makeBitmap()

◆ makeFilter()

◆ onDraw()

◆ onOnceBeforeDraw()

◆ runAsBench()