DDLTileHelper Class Reference

#include <DDLTileHelper.h>

Classes
class	TileData

Public Member Functions
	DDLTileHelper (GrDirectContext *, const GrSurfaceCharacterization &dstChar, const SkIRect &viewport, int numXDivisions, int numYDivisions, bool addRandomPaddingToDst)
void	kickOffThreadedWork (SkTaskGroup *recordingTaskGroup, SkTaskGroup *gpuTaskGroup, GrDirectContext *, SkPicture *)
void	createDDLsInParallel (SkPicture *)
void	createComposeDDL ()
const sk_sp< GrDeferredDisplayList > &	composeDDL () const
void	interleaveDDLCreationAndDraw (GrDirectContext *, SkPicture *)
void	drawAllTilesDirectly (GrDirectContext *, SkPicture *)
void	dropCallbackContexts ()
void	resetAllTiles ()
int	numTiles () const
void	createBackendTextures (SkTaskGroup *, GrDirectContext *)
void	deleteBackendTextures (SkTaskGroup *, GrDirectContext *)

Detailed Description

Definition at line 29 of file DDLTileHelper.h.

Constructor & Destructor Documentation

DDLTileHelper()

DDLTileHelper::DDLTileHelper	(	GrDirectContext *	direct,
		const GrSurfaceCharacterization &	dstChar,
		const SkIRect &	viewport,
		int	numXDivisions,
		int	numYDivisions,
		bool	addRandomPaddingToDst
	)

Definition at line 233 of file DDLTileHelper.cpp.

        : fNumXDivisions(numXDivisions)
        , fNumYDivisions(numYDivisions)
        , fTiles(numXDivisions * numYDivisions)
        , fDstCharacterization(dstChar) {
    SkASSERT(fNumXDivisions > 0 && fNumYDivisions > 0);
 
    int xTileSize = viewport.width()/fNumXDivisions;
    int yTileSize = viewport.height()/fNumYDivisions;
 
    SkRandom rand;
 
    // Create the destination tiles
    for (int y = 0, yOff = 0; y < fNumYDivisions; ++y, yOff += yTileSize) {
        int ySize = (y < fNumYDivisions-1) ? yTileSize : viewport.height()-yOff;
 
        for (int x = 0, xOff = 0; x < fNumXDivisions; ++x, xOff += xTileSize) {
            int xSize = (x < fNumXDivisions-1) ? xTileSize : viewport.width()-xOff;
 
            SkIRect clip = SkIRect::MakeXYWH(xOff, yOff, xSize, ySize);
 
            SkASSERT(viewport.contains(clip));
 
            static const uint32_t kMaxPad = 64;
            int32_t lPad = addRandomPaddingToDst ? rand.nextRangeU(0, kMaxPad) : 0;
            int32_t tPad = addRandomPaddingToDst ? rand.nextRangeU(0, kMaxPad) : 0;
            int32_t rPad = addRandomPaddingToDst ? rand.nextRangeU(0, kMaxPad) : 0;
            int32_t bPad = addRandomPaddingToDst ? rand.nextRangeU(0, kMaxPad) : 0;
 
            fTiles[y*fNumXDivisions+x].init(y*fNumXDivisions+x, direct, dstChar, clip,
                                           {lPad, tPad, rPad, bPad});
        }
    }
}

Member Function Documentation

composeDDL()

const sk_sp< GrDeferredDisplayList > & DDLTileHelper::composeDDL ( ) const

inline

Definition at line 118 of file DDLTileHelper.h.

{ return fComposeDDL; }

createBackendTextures()

void DDLTileHelper::createBackendTextures	(	SkTaskGroup *	taskGroup,
		GrDirectContext *	direct
	)

Definition at line 360 of file DDLTileHelper.cpp.

                                                                                         {
 
    if (taskGroup) {
        for (int i = 0; i < this->numTiles(); ++i) {
            TileData* tile = &fTiles[i];
            if (!tile->initialized()) {
                continue;
            }
 
            taskGroup->add([direct, tile]() { TileData::CreateBackendTexture(direct, tile); });
        }
    } else {
        for (int i = 0; i < this->numTiles(); ++i) {
            TileData::CreateBackendTexture(direct, &fTiles[i]);
        }
    }
}

createComposeDDL()

void DDLTileHelper::createComposeDDL

(

)

Definition at line 74 of file DDLTileHelper.cpp.

                                     {
    SkASSERT(!fComposeDDL);
 
    GrDeferredDisplayListRecorder recorder(fDstCharacterization);
 
    SkCanvas* recordingCanvas = recorder.getCanvas();
 
    for (int i = 0; i < this->numTiles(); ++i) {
        TileData* tile = &fTiles[i];
        if (!tile->initialized()) {
            continue;
        }
 
        sk_sp<SkImage> promiseImage = tile->makePromiseImageForDst(
                                           recordingCanvas->recordingContext()->threadSafeProxy());
 
        SkRect dstRect = SkRect::Make(tile->clipRect());
        SkIRect srcRect = tile->clipRect();
        srcRect.offsetTo(tile->padOffset().x(), tile->padOffset().y());
 
        SkASSERT(promiseImage->bounds().contains(srcRect));
 
        recordingCanvas->drawImageRect(promiseImage.get(), SkRect::Make(srcRect), dstRect,
                                       SkSamplingOptions(), nullptr,
                                       SkCanvas::kStrict_SrcRectConstraint);
    }
 
    fComposeDDL = recorder.detach();
    SkASSERT(fComposeDDL);
}

createDDLsInParallel()

void DDLTileHelper::createDDLsInParallel

(

SkPicture *

picture

)

Definition at line 272 of file DDLTileHelper.cpp.

                                                           {
#if 1
    SkTaskGroup().batch(this->numTiles(), [&](int i) {
        fTiles[i].createDDL(picture);
    });
    SkTaskGroup().add([this]{ this->createComposeDDL(); });
    SkTaskGroup().wait();
#else
    // Use this code path to debug w/o threads
    for (int i = 0; i < this->numTiles(); ++i) {
        fTiles[i].createDDL(picture);
    }
    this->createComposeDDL();
#endif
}

deleteBackendTextures()

void DDLTileHelper::deleteBackendTextures	(	SkTaskGroup *	taskGroup,
		GrDirectContext *	direct
	)

Definition at line 378 of file DDLTileHelper.cpp.

                                                                                         {
    if (taskGroup) {
        for (int i = 0; i < this->numTiles(); ++i) {
            TileData* tile = &fTiles[i];
 
            taskGroup->add([direct, tile]() { TileData::DeleteBackendTexture(direct, tile); });
        }
    } else {
        for (int i = 0; i < this->numTiles(); ++i) {
            TileData::DeleteBackendTexture(direct, &fTiles[i]);
        }
    }
}

drawAllTilesDirectly()

void DDLTileHelper::drawAllTilesDirectly	(	GrDirectContext *	dContext,
		SkPicture *	picture
	)

Definition at line 341 of file DDLTileHelper.cpp.

                                                                                      {
    for (int i = 0; i < this->numTiles(); ++i) {
        fTiles[i].drawSKPDirectly(dContext, picture);
    }
}

dropCallbackContexts()

void DDLTileHelper::dropCallbackContexts

(

)

Definition at line 347 of file DDLTileHelper.cpp.

                                         {
    for (int i = 0; i < this->numTiles(); ++i) {
        fTiles[i].dropCallbackContext();
    }
}

interleaveDDLCreationAndDraw()

void DDLTileHelper::interleaveDDLCreationAndDraw	(	GrDirectContext *	dContext,
		SkPicture *	picture
	)

Definition at line 333 of file DDLTileHelper.cpp.

                                                                                              {
    for (int i = 0; i < this->numTiles(); ++i) {
        fTiles[i].createDDL(picture);
        fTiles[i].draw(dContext);
    }
}

kickOffThreadedWork()

void DDLTileHelper::kickOffThreadedWork	(	SkTaskGroup *	recordingTaskGroup,
		SkTaskGroup *	gpuTaskGroup,
		GrDirectContext *	dContext,
		SkPicture *	picture
	)

Definition at line 303 of file DDLTileHelper.cpp.

                                                            {
    SkASSERT(recordingTaskGroup && gpuTaskGroup && dContext);
 
    for (int i = 0; i < this->numTiles(); ++i) {
        TileData* tile = &fTiles[i];
        if (!tile->initialized()) {
            continue;
        }
 
        // On a recording thread:
        //    generate the tile's DDL
        //    schedule gpu-thread processing of the DDL
        // Note: a finer grained approach would be add a scheduling task which would evaluate
        //       which DDLs were ready to be rendered based on their prerequisites
        recordingTaskGroup->add([tile, gpuTaskGroup, dContext, picture]() {
                                    tile->createDDL(picture);
 
                                    gpuTaskGroup->add([dContext, tile]() {
                                        do_gpu_stuff(dContext, tile);
                                    });
                                });
    }
 
    recordingTaskGroup->add([this] { this->createComposeDDL(); });
}

numTiles()

int DDLTileHelper::numTiles ( ) const

inline

Definition at line 134 of file DDLTileHelper.h.

{ return fNumXDivisions * fNumYDivisions; }

resetAllTiles()

void DDLTileHelper::resetAllTiles

(

)

Definition at line 353 of file DDLTileHelper.cpp.

                                  {
    for (int i = 0; i < this->numTiles(); ++i) {
        fTiles[i].reset();
    }
    fComposeDDL.reset();
}

---

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

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