Inheritance diagram for FilterBoundsSample:

Public Member Functions
	FilterBoundsSample ()

void	load (SkScalar w, SkScalar h) override

void	draw (SkCanvas *canvas) override

Public Member Functions inherited from Slide
virtual SkISize	getDimensions () const

virtual void	gpuTeardown ()

virtual bool	animate (double nanos)

virtual void	resize (SkScalar winWidth, SkScalar winHeight)

virtual void	unload ()

virtual bool	onChar (SkUnichar c)

virtual bool	onMouse (SkScalar x, SkScalar y, skui::InputState state, skui::ModifierKey modifiers)

virtual bool	onGetControls (SkMetaData *)

virtual void	onSetControls (const SkMetaData &)

const SkString &	getName ()

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Additional Inherited Members
Protected Attributes inherited from Slide
SkString	fName

Detailed Description

Definition at line 176 of file FilterBoundsSlide.cpp.

Constructor & Destructor Documentation

◆ FilterBoundsSample()

FilterBoundsSample::FilterBoundsSample ( )

inline

Definition at line 178 of file FilterBoundsSlide.cpp.

178{ fName = "FilterBounds"; }

Slide::fName

SkString fName

Definition Slide.h:54

Member Function Documentation

◆ draw()

void FilterBoundsSample::draw ( SkCanvas * canvas )

inlineoverridevirtual

Implements Slide.

Definition at line 186 of file FilterBoundsSlide.cpp.

                                         {
        // The local content, e.g. what would be submitted to drawRect or the bounds to saveLayer
        const SkRect localContentRect = SkRect::MakeLTRB(100.f, 20.f, 180.f, 140.f);
        SkMatrix ctm = canvas->getLocalToDeviceAs3x3();
 
        // Base rendering of a filter
        SkPaint blurPaint;
        blurPaint.setImageFilter(fBlur);
        canvas->saveLayer(&localContentRect, &blurPaint);
        canvas->drawImageRect(fImage.get(), localContentRect, localContentRect,
                              SkSamplingOptions(SkFilterMode::kLinear),
                              nullptr, SkCanvas::kFast_SrcRectConstraint);
        canvas->restore();
 
        // Now visualize the underlying bounds calculations used to determine the layer for the blur
        SkIRect target = ctm.mapRect(localContentRect).roundOut();
        if (!target.intersect(SkIRect::MakeWH(canvas->imageInfo().width(),
                                              canvas->imageInfo().height()))) {
            return;
        }
        skif::DeviceSpace<SkIRect> targetOutput(target);
        skif::ParameterSpace<SkRect> contentBounds(localContentRect);
        skif::ParameterSpace<SkPoint> contentCenter({localContentRect.centerX(),
                                                     localContentRect.centerY()});
        skif::Mapping mapping;
        SkAssertResult(mapping.decomposeCTM(ctm, fBlur.get(), contentCenter));
 
        // Add axis lines, to show perspective distortion
        canvas->save();
        canvas->setMatrix(mapping.layerToDevice());
        canvas->drawPath(create_axis_path(SkRect(mapping.paramToLayer(contentBounds)), 20.f),
                         line_paint(SK_ColorGRAY));
        canvas->restore();
 
        // Visualize scale factors at the four corners and center of the local rect
        draw_scale_factors(canvas, mapping, localContentRect);
 
        // The device content rect, e.g. the clip bounds if 'localContentRect' were used as a clip
        // before the draw or saveLayer, representing what the filter must cover if it affects
        // transparent black or doesn't have a local content hint.
        canvas->setMatrix(SkMatrix::I());
        canvas->drawRect(ctm.mapRect(localContentRect), line_paint(SK_ColorDKGRAY));
 
        // Layer bounds for the filter, in the layer space compatible with the filter's matrix
        // type requirements.
        skif::LayerSpace<SkIRect> targetOutputInLayer = mapping.deviceToLayer(targetOutput);
        skif::LayerSpace<SkIRect> hintedLayerBounds = as_IFB(fBlur)->getInputBounds(
                mapping, targetOutput, contentBounds);
        skif::LayerSpace<SkIRect> unhintedLayerBounds = as_IFB(fBlur)->getInputBounds(
                mapping, targetOutput, {});
 
        canvas->setMatrix(mapping.layerToDevice());
        canvas->drawRect(SkRect::Make(SkIRect(targetOutputInLayer)),
                         line_paint(SK_ColorDKGRAY, true));
        canvas->drawRect(SkRect::Make(SkIRect(hintedLayerBounds)), line_paint(SK_ColorRED));
        canvas->drawRect(SkRect::Make(SkIRect(unhintedLayerBounds)), line_paint(SK_ColorGREEN));
 
        // For visualization purposes, we want to show the layer-space output, this is what we get
        // when contentBounds is provided as a hint in local/parameter space.
        skif::Mapping layerOnly{mapping.layerMatrix()};
        std::optional<skif::DeviceSpace<SkIRect>> hintedOutputBounds =
                as_IFB(fBlur)->getOutputBounds(layerOnly, contentBounds);
        if (hintedOutputBounds) {
            canvas->drawRect(SkRect::Make(SkIRect(*hintedOutputBounds)), line_paint(SK_ColorBLUE));
        }
 
        canvas->resetMatrix();
        float y = print_info(canvas,
                             mapping.paramToLayer(contentBounds).roundOut(),
                             targetOutput,
                             hintedOutputBounds,
                             unhintedLayerBounds);
 
        // Draw color key for layer visualization
        draw_scale_key(canvas, y);
    }

◆ load()

void FilterBoundsSample::load	(	SkScalar	w,
		SkScalar	h
	)

inlineoverridevirtual

Reimplemented from Slide.

Definition at line 180 of file FilterBoundsSlide.cpp.

                                               {
        fBlur = SkImageFilters::Blur(8.f, 8.f, nullptr);
        fImage = ToolUtils::create_checkerboard_image(
                300, 300, SK_ColorMAGENTA, SK_ColorLTGRAY, 50);
    }

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

third_party/skia/tools/viewer/FilterBoundsSlide.cpp