FilterResultTestAccess Class Reference

Static Public Member Functions
static void	Draw (const skif::Context &ctx, SkDevice *device, const skif::FilterResult &image, bool preserveDeviceState)
static sk_sp< SkShader >	AsShader (const skif::Context &ctx, const skif::FilterResult &image, const skif::LayerSpace< SkIRect > &sampleBounds)
static sk_sp< SkShader >	StrictShader (const skif::Context &ctx, const skif::FilterResult &image)
static skif::FilterResult	Rescale (const skif::Context &ctx, const skif::FilterResult &image, const skif::LayerSpace< SkSize > scale)
static void	TrackStats (skif::Context *ctx, skif::Stats *stats)
static bool	IsIntegerTransform (const skif::FilterResult &image)
static std::optional< std::pair< float, float > >	DeferredScaleFactors (const skif::FilterResult &image)
static bool	IsShaderTilingExpected (const skif::Context &ctx, const skif::FilterResult &image)
static bool	IsShaderClampingExpected (const skif::Context &ctx, const skif::FilterResult &image)

Detailed Description

Definition at line 78 of file FilterResultTest.cpp.

Member Function Documentation

AsShader()

static sk_sp< SkShader > FilterResultTestAccess::AsShader ( const skif::Context &  ctx, const skif::FilterResult &  image, const skif::LayerSpace< SkIRect > &  sampleBounds  )

inlinestatic

Definition at line 88 of file FilterResultTest.cpp.

                                                                                 {
        return image.asShader(ctx, FilterResult::kDefaultSampling,
                              FilterResult::ShaderFlags::kNone, sampleBounds);
    }

DeferredScaleFactors()

static std::optional< std::pair< float, float > > FilterResultTestAccess::DeferredScaleFactors ( const skif::FilterResult &  image )

inlinestatic

Definition at line 130 of file FilterResultTest.cpp.

                                           {
        float scaleFactors[2];
        if (SkMatrix(image.fTransform).getMinMaxScales(scaleFactors)) {
            return {{scaleFactors[0], scaleFactors[1]}};
        } else {
            return {};
        }
    }

Draw()

static void FilterResultTestAccess::Draw ( const skif::Context &  ctx, SkDevice *  device, const skif::FilterResult &  image, bool  preserveDeviceState  )

inlinestatic

Definition at line 81 of file FilterResultTest.cpp.

                                               {
        image.draw(ctx, device, preserveDeviceState, /*blender=*/nullptr);
    }

IsIntegerTransform()

static bool FilterResultTestAccess::IsIntegerTransform ( const skif::FilterResult &  image )

inlinestatic

Definition at line 123 of file FilterResultTest.cpp.

                                                                  {
        SkMatrix m = SkMatrix(image.fTransform);
        return m.isTranslate() &&
               SkScalarIsInt(m.getTranslateX()) &&
               SkScalarIsInt(m.getTranslateY());
    }

IsShaderClampingExpected()

static bool FilterResultTestAccess::IsShaderClampingExpected ( const skif::Context &  ctx, const skif::FilterResult &  image  )

inlinestatic

Definition at line 161 of file FilterResultTest.cpp.

                                                                        {
        auto analysis = image.analyzeBounds(ctx.desiredOutput());
        if (analysis & BoundsAnalysis::kHasLayerFillingEffect) {
            // The image won't be drawn directly so some form of shader is needed. The faster clamp
            // can be used when clamping explicitly or decal-with-transparent-padding.
            if (image.tileMode() == SkTileMode::kClamp ||
                (image.tileMode() == SkTileMode::kDecal &&
                 image.fBoundary == FilterResult::PixelBoundary::kTransparent)) {
                return true;
            } else {
                // These cases should be covered by the more expensive shader tiling.
                SkASSERT(IsShaderTilingExpected(ctx, image));
                return false;
            }
        }
        // If we got here, it will be drawn directly but a clamp can be needed if the data outside
        // the image is unknown and sampling might pull those values in accidentally.
        return image.fBoundary == FilterResult::PixelBoundary::kUnknown;
    }

IsShaderTilingExpected()

static bool FilterResultTestAccess::IsShaderTilingExpected ( const skif::Context &  ctx, const skif::FilterResult &  image  )

inlinestatic

Definition at line 140 of file FilterResultTest.cpp.

                                                                      {
        if (image.tileMode() == SkTileMode::kClamp) {
            return false;
        }
        if (image.tileMode() == SkTileMode::kDecal &&
            image.fBoundary == FilterResult::PixelBoundary::kTransparent) {
            return false;
        }
        auto analysis = image.analyzeBounds(ctx.desiredOutput());
        if (!(analysis & BoundsAnalysis::kHasLayerFillingEffect)) {
            return false;
        }
 
        // If we got here, it's either a mirror/repeat tile mode that's visible so a shader has to
        // be used if the image isn't HW tileable; OR it's a decal tile mode without transparent
        // padding that can't be drawn directly (in this case hasLayerFillingEffect implies a
        // color filter that has to evaluate the decal'ed sampling).
        return true;
    }

Rescale()

static skif::FilterResult FilterResultTestAccess::Rescale ( const skif::Context &  ctx, const skif::FilterResult &  image, const skif::LayerSpace< SkSize >  scale  )

inlinestatic

Definition at line 113 of file FilterResultTest.cpp.

                                                                          {
        return image.rescale(ctx, scale, /*enforceDecal=*/false);
    }

StrictShader()

static sk_sp< SkShader > FilterResultTestAccess::StrictShader ( const skif::Context &  ctx, const skif::FilterResult &  image  )

inlinestatic

Definition at line 95 of file FilterResultTest.cpp.

                                                                       {
        auto analysis = image.analyzeBounds(ctx.desiredOutput());
        if (analysis & FilterResult::BoundsAnalysis::kRequiresLayerCrop) {
            // getAnalyzedShaderView() doesn't include the layer crop, this will be handled by
            // the FilterResultImageResolver.
           return nullptr;
        } else {
            // Add flags to ensure no deferred effects or clamping logic are optimized away.
            analysis |= BoundsAnalysis::kDstBoundsNotCovered;
            analysis |= BoundsAnalysis::kRequiresShaderTiling;
            if (image.tileMode() == SkTileMode::kDecal) {
                analysis |= BoundsAnalysis::kRequiresDecalInLayerSpace;
            }
            return image.getAnalyzedShaderView(ctx, image.sampling(), analysis);
        }
    }

TrackStats()

static void FilterResultTestAccess::TrackStats ( skif::Context *  ctx, skif::Stats *  stats  )

inlinestatic

Definition at line 119 of file FilterResultTest.cpp.

                                                               {
        ctx->fStats = stats;
    }

---

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

• third_party/skia/tests/FilterResultTest.cpp