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 bool	IsShaderTilingExpected (const skif::Context &ctx, const skif::FilterResult &image, bool rescaling)
static bool	IsShaderClampingExpected (const skif::Context &ctx, const skif::FilterResult &image, bool rescaling)

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);
    }

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, bool  rescaling  )

inlinestatic

Definition at line 156 of file FilterResultTest.cpp.

                                                         {
        auto analysis = image.analyzeBounds(ctx.desiredOutput());
        if (analysis & BoundsAnalysis::kHasLayerFillingEffect ||
            (image.tileMode() == SkTileMode::kDecal && rescaling)) {
            // 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.
            // TODO(b/323886180): Once rescaling can draw decals directly, decal-with-transparent
            // padding should only need clamping when there's a layer-filling color filter as well.
            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, but if we
                // are rescaling with a deferrable tile mode, it can still be converted to a clamp.
                SkASSERT(IsShaderTilingExpected(ctx, image, rescaling));
                return rescaling;
            }
        }
        // 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, bool  rescaling  )

inlinestatic

Definition at line 130 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) &&
             (image.tileMode() == SkTileMode::kRepeat || image.tileMode() == SkTileMode::kMirror ||
              (image.tileMode() == SkTileMode::kDecal && !rescaling))) {
            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).
        // TODO(b/323886180): Rescaling with decal images does not draw directly but should, so it
        // will eventually avoid the expensive decal shader.
        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