ImageCacheratorGM Class Reference

Inheritance diagram for ImageCacheratorGM:

Public Member Functions
	ImageCacheratorGM (const char suffix[], FactoryFunc factory, bool useTexture)
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
SkISize	getISize () override
void	onOnceBeforeDraw () override
bool	makeCaches (SkCanvas *canvas)
void	drawRow (GrDirectContext *dContext, SkCanvas *canvas, float scale) const
DrawResult	onDraw (SkCanvas *canvas, SkString *errorMsg) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual void	onDraw (SkCanvas *)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Static Protected Member Functions
static void	draw_placeholder (SkCanvas *canvas, SkScalar x, SkScalar y, int w, int h)
static void	draw_as_bitmap (GrDirectContext *dContext, SkCanvas *canvas, SkImage *image, SkScalar x, SkScalar y)
static void	draw_as_tex (SkCanvas *canvas, SkImage *image, SkScalar x, SkScalar y)

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 250 of file image_pict.cpp.

Constructor & Destructor Documentation

ImageCacheratorGM()

ImageCacheratorGM::ImageCacheratorGM ( const char  suffix[], FactoryFunc  factory, bool  useTexture  )

inline

Definition at line 261 of file image_pict.cpp.

                                                                                 :
                    fFactory(factory), fUseTexture(useTexture) {
        fName.printf("image-cacherator-from-%s", suffix);
    }

Member Function Documentation

draw_as_bitmap()

static void ImageCacheratorGM::draw_as_bitmap ( GrDirectContext *  dContext, SkCanvas *  canvas, SkImage *  image, SkScalar  x, SkScalar  y  )

inlinestaticprotected

Definition at line 344 of file image_pict.cpp.

                                                       {
        SkBitmap bitmap;
        if (as_IB(image)->getROPixels(dContext, &bitmap)) {
            canvas->drawImage(bitmap.asImage(), x, y);
        } else {
            draw_placeholder(canvas, x, y, image->width(), image->height());
        }
    }

draw_as_tex()

static void ImageCacheratorGM::draw_as_tex ( SkCanvas *  canvas, SkImage *  image, SkScalar  x, SkScalar  y  )

inlinestaticprotected

Definition at line 354 of file image_pict.cpp.

                                                                                      {
        if (as_IB(image)->isGaneshBacked()) {
            // The gpu-backed images are drawn in this manner bc the generator backed images
            // aren't considered texture-backed
            auto [view, ct] =
                    skgpu::ganesh::AsView(canvas->recordingContext(), image, skgpu::Mipmapped::kNo);
            if (!view) {
                // show placeholder if we have no texture
                draw_placeholder(canvas, x, y, image->width(), image->height());
                return;
            }
            SkColorInfo colorInfo(GrColorTypeToSkColorType(ct),
                                  image->alphaType(),
                                  image->refColorSpace());
            // No API to draw a GrTexture directly, so we cheat and create a private image subclass
            sk_sp<SkImage> texImage(new SkImage_Ganesh(sk_ref_sp(canvas->recordingContext()),
                                                       image->uniqueID(),
                                                       std::move(view),
                                                       std::move(colorInfo)));
            canvas->drawImage(texImage.get(), x, y);
        } else {
            canvas->drawImage(image, x, y);
        }
    }

draw_placeholder()

static void ImageCacheratorGM::draw_placeholder ( SkCanvas *  canvas, SkScalar  x, SkScalar  y, int  w, int  h  )

inlinestaticprotected

Definition at line 335 of file image_pict.cpp.

                                                                                         {
        SkPaint paint;
        paint.setStyle(SkPaint::kStroke_Style);
        SkRect r = SkRect::MakeXYWH(x, y, SkIntToScalar(w), SkIntToScalar(h));
        canvas->drawRect(r, paint);
        canvas->drawLine(r.left(), r.top(), r.right(), r.bottom(), paint);
        canvas->drawLine(r.left(), r.bottom(), r.right(), r.top(), paint);
    }

drawRow()

void ImageCacheratorGM::drawRow ( GrDirectContext *  dContext, SkCanvas *  canvas, float  scale  ) const

inlineprotected

Definition at line 379 of file image_pict.cpp.

                                                                                 {
        canvas->scale(scale, scale);
 
        SkMatrix matrix = SkMatrix::Translate(-100, -100);
        canvas->drawPicture(fPicture, &matrix, nullptr);
 
        // Draw the tex first, so it doesn't hit a lucky cache from the raster version. This
        // way we also can force the generateTexture call.
 
        draw_as_tex(canvas, fImage.get(), 150, 0);
        draw_as_tex(canvas, fImageSubset.get(), 150+101, 0);
 
        draw_as_bitmap(dContext, canvas, fImage.get(), 310, 0);
        draw_as_bitmap(dContext, canvas, fImageSubset.get(), 310+101, 0);
    }

getISize()

SkISize ImageCacheratorGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 269 of file image_pict.cpp.

{ return SkISize::Make(960, 450); }

getName()

SkString ImageCacheratorGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 267 of file image_pict.cpp.

{ return fName; }

makeCaches()

bool ImageCacheratorGM::makeCaches ( SkCanvas *  canvas )

inlineprotected

Definition at line 278 of file image_pict.cpp.

                                      {
        auto dContext = GrAsDirectContext(canvas->recordingContext());
 
        {
            auto gen = fFactory(canvas, fPicture);
            if (!gen) {
                return false;
            }
            if (fUseTexture) {
                auto textureGen = std::unique_ptr<GrTextureGenerator>(
                        static_cast<GrTextureGenerator*>(gen.release()));
                fImage = SkImages::DeferredFromTextureGenerator(std::move(textureGen));
            } else {
                fImage = SkImages::DeferredFromGenerator(std::move(gen));
            }
            if (!fImage) {
                return false;
            }
            SkASSERT(fImage->dimensions() == SkISize::Make(100, 100));
        }
 
        {
            const SkIRect subset = SkIRect::MakeLTRB(50, 50, 100, 100);
 
            // We re-create the generator here on the off chance that making a subset from
            // 'fImage' might perturb its state.
            auto gen = fFactory(canvas, fPicture);
            if (!gen) {
                return false;
            }
 
            if (dContext) {
                 if (fUseTexture) {
                    auto textureGen = std::unique_ptr<GrTextureGenerator>(
                        static_cast<GrTextureGenerator*>(gen.release()));
                    fImageSubset = SkImages::DeferredFromTextureGenerator(std::move(textureGen))
                            ->makeSubset(dContext, subset);
                } else {
                    fImageSubset = SkImages::DeferredFromGenerator(std::move(gen))
                            ->makeSubset(dContext, subset);
                }
            } else {
#if defined(SK_GRAPHITE)
                auto recorder = canvas->recorder();
                fImageSubset = SkImages::DeferredFromGenerator(std::move(gen))
                                       ->makeSubset(recorder, subset, {});
#endif
            }
            if (!fImageSubset) {
                return false;
            }
            SkASSERT(fImageSubset->dimensions() == SkISize::Make(50, 50));
        }
 
        return true;
    }

onDraw()

DrawResult ImageCacheratorGM::onDraw ( SkCanvas *  canvas, SkString *  errorMsg  )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 395 of file image_pict.cpp.

                                                                     {
        auto dContext = GrAsDirectContext(canvas->recordingContext());
        if (!this->makeCaches(canvas)) {
            errorMsg->printf("Could not create cached images");
            return DrawResult::kSkip;
        }
 
        canvas->save();
            canvas->translate(20, 20);
            this->drawRow(dContext, canvas, 1.0);
        canvas->restore();
 
        canvas->save();
            canvas->translate(20, 150);
            this->drawRow(dContext, canvas, 0.25f);
        canvas->restore();
 
        canvas->save();
            canvas->translate(20, 220);
            this->drawRow(dContext, canvas, 2.0f);
        canvas->restore();
 
        return DrawResult::kOk;
    }

onOnceBeforeDraw()

void ImageCacheratorGM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 271 of file image_pict.cpp.

                                     {
        const SkRect bounds = SkRect::MakeXYWH(100, 100, 100, 100);
        SkPictureRecorder recorder;
        draw_something(recorder.beginRecording(bounds), bounds);
        fPicture = recorder.finishRecordingAsPicture();
    }

---

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

• third_party/skia/gm/image_pict.cpp