skgpu::Plot Class Reference

#include <AtlasTypes.h>

Inheritance diagram for skgpu::Plot:

Public Member Functions
	Plot (int pageIndex, int plotIndex, AtlasGenerationCounter *generationCounter, int offX, int offY, int width, int height, SkColorType colorType, size_t bpp)
uint32_t	pageIndex () const
uint32_t	plotIndex () const
uint64_t	genID () const
PlotLocator	plotLocator () const
	SkDEBUGCODE (size_t bpp() const { return fBytesPerPixel;}) bool addRect(int width
void *	dataAt (const AtlasLocator &atlasLocator)
void	copySubImage (const AtlasLocator &atlasLocator, const void *image)
SkIPoint	prepForRender (const AtlasLocator &, SkAutoPixmapStorage *)
bool	addSubImage (int width, int height, const void *image, AtlasLocator *atlasLocator)
skgpu::AtlasToken	lastUploadToken () const
skgpu::AtlasToken	lastUseToken () const
void	setLastUploadToken (skgpu::AtlasToken token)
void	setLastUseToken (skgpu::AtlasToken token)
int	flushesSinceLastUsed ()
void	resetFlushesSinceLastUsed ()
void	incFlushesSinceLastUsed ()
bool	needsUpload ()
std::pair< const void *, SkIRect >	prepareForUpload ()
void	resetRects ()
void	markFullIfUsed ()
sk_sp< Plot >	clone () const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Public Attributes
int	height
int AtlasLocator *	atlasLocator
const uint32_t	fPageIndex: 16
const uint32_t	fPlotIndex: 16

Detailed Description

The backing texture for an atlas is broken into a spatial grid of Plots. The Plots keep track of subimage placement via their Rectanizer. A Plot may be subclassed if the atlas class needs to track additional information.

Definition at line 435 of file AtlasTypes.h.

Constructor & Destructor Documentation

Plot()

skgpu::Plot::Plot	(	int	pageIndex,
		int	plotIndex,
		AtlasGenerationCounter *	generationCounter,
		int	offX,
		int	offY,
		int	width,
		int	height,
		SkColorType	colorType,
		size_t	bpp
	)

Definition at line 18 of file AtlasTypes.cpp.

        : fLastUpload(AtlasToken::InvalidToken())
        , fLastUse(AtlasToken::InvalidToken())
        , fFlushesSinceLastUse(0)
        , fPageIndex(pageIndex)
        , fPlotIndex(plotIndex)
        , fGenerationCounter(generationCounter)
        , fGenID(fGenerationCounter->next())
        , fPlotLocator(fPageIndex, fPlotIndex, fGenID)
        , fData(nullptr)
        , fWidth(width)
        , fHeight(height)
        , fX(offX)
        , fY(offY)
        , fRectanizer(width, height)
        , fOffset(SkIPoint16::Make(fX * fWidth, fY * fHeight))
        , fColorType(colorType)
        , fBytesPerPixel(bpp)
        , fIsFull(false)
#ifdef SK_DEBUG
        , fDirty(false)
#endif
{
    // We expect the allocated dimensions to be a multiple of 4 bytes
    SkASSERT(((width*fBytesPerPixel) & 0x3) == 0);
    // The padding for faster uploads only works for 1, 2 and 4 byte texels
    SkASSERT(fBytesPerPixel != 3 && fBytesPerPixel <= 4);
    fDirtyRect.setEmpty();
}

Member Function Documentation

addSubImage()

bool skgpu::Plot::addSubImage	(	int	width,
		int	height,
		const void *	image,
		AtlasLocator *	atlasLocator
	)

Definition at line 123 of file AtlasTypes.cpp.

                                                                                           {
    if (fIsFull || !this->addRect(width, height, atlasLocator)) {
        return false;
    }
    this->copySubImage(*atlasLocator, image);
 
    return true;
}

clone()

sk_sp< Plot > skgpu::Plot::clone ( ) const

inline

Create a clone of this plot. The cloned plot will take the place of the current plot in the atlas

Definition at line 497 of file AtlasTypes.h.

                              {
        return sk_sp<Plot>(new Plot(
            fPageIndex, fPlotIndex, fGenerationCounter, fX, fY, fWidth, fHeight, fColorType,
            fBytesPerPixel));
    }

copySubImage()

void skgpu::Plot::copySubImage	(	const AtlasLocator &	atlasLocator,
		const void *	image
	)

Definition at line 99 of file AtlasTypes.cpp.

                                                                 {
    const unsigned char* imagePtr = (const unsigned char*)image;
    unsigned char* dataPtr = (unsigned char*)this->dataAt(al);
    int width = al.width();
    int height = al.height();
    size_t rowBytes = width * fBytesPerPixel;
 
    // copy into the data buffer, swizzling as we go if this is ARGB data
    constexpr bool kBGRAIsNative = kN32_SkColorType == kBGRA_8888_SkColorType;
    if (4 == fBytesPerPixel && kBGRAIsNative) {
        for (int i = 0; i < height; ++i) {
            SkOpts::RGBA_to_BGRA((uint32_t*)dataPtr, (const uint32_t*)imagePtr, width);
            dataPtr += fBytesPerPixel * fWidth;
            imagePtr += rowBytes;
        }
    } else {
        for (int i = 0; i < height; ++i) {
            memcpy(dataPtr, imagePtr, rowBytes);
            dataPtr += fBytesPerPixel * fWidth;
            imagePtr += rowBytes;
        }
    }
}

dataAt()

void * skgpu::Plot::dataAt

(

const AtlasLocator &

atlasLocator

)

Definition at line 71 of file AtlasTypes.cpp.

                                                   {
    if (!fData) {
        fData = reinterpret_cast<unsigned char*>(
                        sk_calloc_throw(fBytesPerPixel * fWidth * fHeight));
    }
    // point ourselves at the right starting spot
    unsigned char* dataPtr = fData;
    SkIPoint topLeft = atlasLocator.topLeft();
    // Assert if we're not accessing the correct Plot
    SkASSERT(topLeft.fX >= fOffset.fX && topLeft.fX < fOffset.fX + fWidth &&
             topLeft.fY >= fOffset.fY && topLeft.fY < fOffset.fY + fHeight);
    topLeft -= SkIPoint::Make(fOffset.fX, fOffset.fY);
    dataPtr += fBytesPerPixel * fWidth * topLeft.fY;
    dataPtr += fBytesPerPixel * topLeft.fX;
 
    return dataPtr;
}

flushesSinceLastUsed()

int skgpu::Plot::flushesSinceLastUsed ( )

inline

Definition at line 483 of file AtlasTypes.h.

{ return fFlushesSinceLastUse; }

genID()

uint64_t skgpu::Plot::genID ( ) const

inline

genID() is incremented when the plot is evicted due to a atlas spill. It is used to know if a particular subimage is still present in the atlas.

Definition at line 450 of file AtlasTypes.h.

{ return fGenID; }

incFlushesSinceLastUsed()

void skgpu::Plot::incFlushesSinceLastUsed ( )

inline

Definition at line 485 of file AtlasTypes.h.

{ fFlushesSinceLastUse++; }

lastUploadToken()

skgpu::AtlasToken skgpu::Plot::lastUploadToken ( ) const

inline

To manage the lifetime of a plot, we use two tokens. We use the last upload token to know when we can 'piggy back' uploads, i.e. if the last upload hasn't been flushed to the gpu, we don't need to issue a new upload even if we update the cpu backing store. We use lastUse to determine when we can evict a plot from the cache, i.e. if the last use has already flushed through the gpu then we can reuse the plot.

Definition at line 478 of file AtlasTypes.h.

{ return fLastUpload; }

lastUseToken()

skgpu::AtlasToken skgpu::Plot::lastUseToken ( ) const

inline

Definition at line 479 of file AtlasTypes.h.

{ return fLastUse; }

markFullIfUsed()

void skgpu::Plot::markFullIfUsed ( )

inline

Definition at line 491 of file AtlasTypes.h.

{ fIsFull = !fDirtyRect.isEmpty(); }

needsUpload()

bool skgpu::Plot::needsUpload ( )

inline

Definition at line 487 of file AtlasTypes.h.

{ return !fDirtyRect.isEmpty(); }

pageIndex()

uint32_t skgpu::Plot::pageIndex ( ) const

inline

Definition at line 442 of file AtlasTypes.h.

{ return fPageIndex; }

plotIndex()

uint32_t skgpu::Plot::plotIndex ( ) const

inline

plotIndex() is a unique id for the plot relative to the owning GrAtlas and page.

Definition at line 445 of file AtlasTypes.h.

{ return fPlotIndex; }

plotLocator()

PlotLocator skgpu::Plot::plotLocator ( ) const

inline

Definition at line 451 of file AtlasTypes.h.

                                    {
        SkASSERT(fPlotLocator.isValid());
        return fPlotLocator;
    }

prepareForUpload()

std::pair< const void *, SkIRect > skgpu::Plot::prepareForUpload

(

)

Definition at line 132 of file AtlasTypes.cpp.

                                                     {
    // We should only be issuing uploads if we are dirty
    SkASSERT(fDirty);
    if (!fData) {
        return {nullptr, {}};
    }
    size_t rowBytes = fBytesPerPixel * fWidth;
    const unsigned char* dataPtr;
    SkIRect offsetRect;
    // Clamp to 4-byte aligned boundaries
    unsigned int clearBits = 0x3 / fBytesPerPixel;
    fDirtyRect.fLeft &= ~clearBits;
    fDirtyRect.fRight += clearBits;
    fDirtyRect.fRight &= ~clearBits;
    SkASSERT(fDirtyRect.fRight <= fWidth);
    // Set up dataPtr
    dataPtr = fData;
    dataPtr += rowBytes * fDirtyRect.fTop;
    dataPtr += fBytesPerPixel * fDirtyRect.fLeft;
    offsetRect = fDirtyRect.makeOffset(fOffset.fX, fOffset.fY);
 
    fDirtyRect.setEmpty();
    fIsFull = false;
    SkDEBUGCODE(fDirty = false);
 
    return { dataPtr, offsetRect };
}

prepForRender()

SkIPoint skgpu::Plot::prepForRender	(	const AtlasLocator &	al,
		SkAutoPixmapStorage *	pixmap
	)

Definition at line 89 of file AtlasTypes.cpp.

                                                                                {
    if (!fData) {
        fData = reinterpret_cast<unsigned char*>(
                        sk_calloc_throw(fBytesPerPixel * fWidth * fHeight));
    }
    pixmap->reset(SkImageInfo::Make(fWidth, fHeight, fColorType, kOpaque_SkAlphaType),
                  fData, fBytesPerPixel * fWidth);
    return al.topLeft() - SkIPoint::Make(fOffset.fX, fOffset.fY);
}

resetFlushesSinceLastUsed()

void skgpu::Plot::resetFlushesSinceLastUsed ( )

inline

Definition at line 484 of file AtlasTypes.h.

{ fFlushesSinceLastUse = 0; }

resetRects()

void skgpu::Plot::resetRects

(

)

Definition at line 160 of file AtlasTypes.cpp.

                      {
    fRectanizer.reset();
    fGenID = fGenerationCounter->next();
    fPlotLocator = PlotLocator(fPageIndex, fPlotIndex, fGenID);
    fLastUpload = AtlasToken::InvalidToken();
    fLastUse = AtlasToken::InvalidToken();
 
    // zero out the plot
    if (fData) {
        sk_bzero(fData, fBytesPerPixel * fWidth * fHeight);
    }
 
    fDirtyRect.setEmpty();
    fIsFull = false;
    SkDEBUGCODE(fDirty = false;)
}

setLastUploadToken()

void skgpu::Plot::setLastUploadToken ( skgpu::AtlasToken  token )

inline

Definition at line 480 of file AtlasTypes.h.

{ fLastUpload = token; }

setLastUseToken()

void skgpu::Plot::setLastUseToken ( skgpu::AtlasToken  token )

inline

Definition at line 481 of file AtlasTypes.h.

{ fLastUse = token; }

SkDEBUGCODE()

skgpu::Plot::SkDEBUGCODE

(

size_t bpp() const { return fBytesPerPixel;}

)

To add data to the Plot, first call addRect to see if it's possible. If successful, use the atlasLocator to get a pointer to the location in the atlas via dataAt() and render to that location, or if you already have data use copySubImage().

Member Data Documentation

atlasLocator

int AtlasLocator* skgpu::Plot::atlasLocator

Definition at line 462 of file AtlasTypes.h.

fPageIndex

const uint32_t skgpu::Plot::fPageIndex

Definition at line 518 of file AtlasTypes.h.

fPlotIndex

const uint32_t skgpu::Plot::fPlotIndex

Definition at line 519 of file AtlasTypes.h.

height

int skgpu::Plot::height

Definition at line 462 of file AtlasTypes.h.

---

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

• third_party/skia/src/gpu/AtlasTypes.h
• third_party/skia/src/gpu/AtlasTypes.cpp