DDLTileHelper::TileData Class Reference

#include <DDLTileHelper.h>

Public Member Functions
	TileData ()
	~TileData ()
bool	initialized () const
void	init (int id, GrDirectContext *, const GrSurfaceCharacterization &dstChar, const SkIRect &clip, const SkIRect &paddingOutsets)
void	createDDL (const SkPicture *)
void	dropDDL ()
void	precompile (GrDirectContext *)
void	drawSKPDirectly (GrDirectContext *, const SkPicture *)
void	draw (GrDirectContext *)
void	reset ()
int	id () const
SkIRect	clipRect () const
SkISize	paddedRectSize () const
SkIVector	padOffset () const
GrDeferredDisplayList *	ddl ()
sk_sp< SkImage >	makePromiseImageForDst (sk_sp< GrContextThreadSafeProxy >)
void	dropCallbackContext ()

Static Public Member Functions
static void	CreateBackendTexture (GrDirectContext *, TileData *)
static void	DeleteBackendTexture (GrDirectContext *, TileData *)

Detailed Description

Definition at line 33 of file DDLTileHelper.h.

Constructor & Destructor Documentation

TileData()

DDLTileHelper::TileData::TileData

(

)

Definition at line 48 of file DDLTileHelper.cpp.

{}

~TileData()

DDLTileHelper::TileData::~TileData

(

)

Definition at line 49 of file DDLTileHelper.cpp.

{}

Member Function Documentation

clipRect()

SkIRect DDLTileHelper::TileData::clipRect ( ) const

inline

Definition at line 65 of file DDLTileHelper.h.

{ return fClip; }

CreateBackendTexture()

void DDLTileHelper::TileData::CreateBackendTexture ( GrDirectContext *  direct, TileData *  tile  )

static

Definition at line 198 of file DDLTileHelper.cpp.

                                                                                        {
    SkASSERT(tile->fCallbackContext && !tile->fCallbackContext->promiseImageTexture());
 
    const GrSurfaceCharacterization& c = tile->fPlaybackChar;
    GrBackendTexture beTex =
            direct->createBackendTexture(c.width(),
                                         c.height(),
                                         c.colorType(),
                                         skgpu::Mipmapped(c.isMipMapped()),
                                         GrRenderable::kYes,
                                         GrProtected::kNo,
                                         /*label=*/"DDLTile_TileData_CreateBackendTexture");
    tile->fCallbackContext->setBackendTexture(beTex);
}

createDDL()

void DDLTileHelper::TileData::createDDL

(

const SkPicture *

picture

)

Definition at line 51 of file DDLTileHelper.cpp.

                                                              {
    SkASSERT(!fDisplayList && picture);
 
    auto recordingChar = fPlaybackChar.createResized(fClip.width(), fClip.height());
    SkASSERT(recordingChar.isValid());
 
    GrDeferredDisplayListRecorder recorder(recordingChar);
 
    // DDL TODO: the DDLRecorder's rContext isn't initialized until getCanvas is called.
    // Maybe set it up in the ctor?
    SkCanvas* recordingCanvas = recorder.getCanvas();
 
    // We always record the DDL in the (0,0) .. (clipWidth, clipHeight) coordinates
    recordingCanvas->clipRect(SkRect::MakeWH(fClip.width(), fClip.height()));
    recordingCanvas->translate(-fClip.fLeft, -fClip.fTop);
 
    // Note: in this use case we only render a picture to the deferred canvas
    // but, more generally, clients will use arbitrary draw calls.
    recordingCanvas->drawPicture(picture);
 
    fDisplayList = recorder.detach();
}

ddl()

GrDeferredDisplayList * DDLTileHelper::TileData::ddl ( )

inline

Definition at line 72 of file DDLTileHelper.h.

{ return fDisplayList.get(); }

DeleteBackendTexture()

void DDLTileHelper::TileData::DeleteBackendTexture ( GrDirectContext *  dContext, TileData *  tile  )

static

Definition at line 213 of file DDLTileHelper.cpp.

                                                                                          {
    if (!tile->initialized() || dContext->abandoned()) {
        return;
    }
 
    SkASSERT(tile->fCallbackContext);
 
    // TODO: it seems that, on the Linux bots, backend texture creation is failing
    // a lot (skbug.com/10142)
    SkASSERT(!tile->fCallbackContext->promiseImageTexture() ||
             tile->fCallbackContext->promiseImageTexture()->backendTexture().isValid());
 
    tile->fTileSurface = nullptr;
 
    SkASSERT(tile->fCallbackContext->unique());
    tile->fCallbackContext.reset();
}

draw()

void DDLTileHelper::TileData::draw

(

GrDirectContext *

direct

)

Definition at line 157 of file DDLTileHelper.cpp.

                                                        {
    SkASSERT(fDisplayList && !fTileSurface);
 
    fTileSurface = this->makeWrappedTileDest(direct);
    if (fTileSurface) {
        skgpu::ganesh::DrawDDL(fTileSurface, fDisplayList);
 
        // We can't snap an image here bc, since we're using wrapped backend textures for the
        // surfaces, that would incur a copy.
    }
}

drawSKPDirectly()

void DDLTileHelper::TileData::drawSKPDirectly	(	GrDirectContext *	dContext,
		const SkPicture *	picture
	)

Definition at line 138 of file DDLTileHelper.cpp.

                                                                        {
    SkASSERT(!fDisplayList && !fTileSurface && picture);
 
    fTileSurface = this->makeWrappedTileDest(dContext);
    if (fTileSurface) {
        SkCanvas* tileCanvas = fTileSurface->getCanvas();
 
        SkASSERT(this->padOffset().isZero() && this->paddedRectSize() == fClip.size());
        tileCanvas->clipRect(SkRect::MakeWH(fClip.width(), fClip.height()));
        tileCanvas->translate(-fClip.fLeft, -fClip.fTop);
 
        tileCanvas->drawPicture(picture);
 
        // We can't snap an image here bc, since we're using wrapped backend textures for the
        // surfaces, that would incur a copy.
    }
}

dropCallbackContext()

void DDLTileHelper::TileData::dropCallbackContext ( )

inline

Definition at line 75 of file DDLTileHelper.h.

{ fCallbackContext.reset(); }

dropDDL()

void DDLTileHelper::TileData::dropDDL ( )

inline

Definition at line 49 of file DDLTileHelper.h.

{ fDisplayList.reset(); }

id()

int DDLTileHelper::TileData::id ( ) const

inline

Definition at line 64 of file DDLTileHelper.h.

{ return fID; }

init()

void DDLTileHelper::TileData::init	(	int	id,
		GrDirectContext *	direct,
		const GrSurfaceCharacterization &	dstChar,
		const SkIRect &	clip,
		const SkIRect &	paddingOutsets
	)

Definition at line 28 of file DDLTileHelper.cpp.

                                                                  {
    fID = id;
    fClip = clip;
    fPaddingOutsets = paddingOutsets;
 
    fPlaybackChar  = dstSurfaceCharacterization.createResized(this->paddedRectSize().width(),
                                                              this->paddedRectSize().height());
    SkASSERT(fPlaybackChar.isValid());
 
    SkDEBUGCODE(const GrCaps* caps = direct->priv().caps());
    SkASSERT(caps->isFormatTexturable(fPlaybackChar.backendFormat(),
                                      fPlaybackChar.backendFormat().textureType()));
 
    fCallbackContext.reset(new PromiseImageCallbackContext(direct, fPlaybackChar.backendFormat()));
}

initialized()

bool DDLTileHelper::TileData::initialized ( ) const

inline

Definition at line 38 of file DDLTileHelper.h.

{ return fID != -1; }

makePromiseImageForDst()

sk_sp< SkImage > DDLTileHelper::TileData::makePromiseImageForDst

(

sk_sp< GrContextThreadSafeProxy >

threadSafeProxy

)

Definition at line 176 of file DDLTileHelper.cpp.

                                                                                                 {
    SkASSERT(fCallbackContext);
 
    // The promise image gets a ref on the promise callback context
    sk_sp<SkImage> promiseImage =
            SkImages::PromiseTextureFrom(std::move(threadSafeProxy),
                                         fCallbackContext->backendFormat(),
                                         this->paddedRectSize(),
                                         skgpu::Mipmapped::kNo,
                                         GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,
                                         fPlaybackChar.colorType(),
                                         kPremul_SkAlphaType,
                                         fPlaybackChar.refColorSpace(),
                                         PromiseImageCallbackContext::PromiseImageFulfillProc,
                                         PromiseImageCallbackContext::PromiseImageReleaseProc,
                                         (void*)this->refCallbackContext().release());
    fCallbackContext->wasAddedToImage();
 
    return promiseImage;
}

paddedRectSize()

SkISize DDLTileHelper::TileData::paddedRectSize ( ) const

inline

Definition at line 66 of file DDLTileHelper.h.

                                       {
            return { fClip.width() + fPaddingOutsets.fLeft + fPaddingOutsets.fRight,
                     fClip.height() + fPaddingOutsets.fTop + fPaddingOutsets.fBottom };
        }

padOffset()

SkIVector DDLTileHelper::TileData::padOffset ( ) const

inline

Definition at line 70 of file DDLTileHelper.h.

{ return { fPaddingOutsets.fLeft, fPaddingOutsets.fTop }; }

precompile()

void DDLTileHelper::TileData::precompile

(

GrDirectContext *

direct

)

Definition at line 105 of file DDLTileHelper.cpp.

                                                              {
    if (!this->initialized()) {
        return;
    }
 
    SkASSERT(fDisplayList);
 
    GrDeferredDisplayList::ProgramIterator iter(direct, fDisplayList.get());
    for (; !iter.done(); iter.next()) {
        iter.compile();
    }
}

reset()

void DDLTileHelper::TileData::reset

(

)

Definition at line 169 of file DDLTileHelper.cpp.

                                  {
    // TODO: when DDLs are re-renderable we don't need to do this
    fDisplayList = nullptr;
 
    fTileSurface = nullptr;
}

---

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

• third_party/skia/tools/DDLTileHelper.h
• third_party/skia/tools/DDLTileHelper.cpp