GrDynamicAtlas Class Reference

#include <GrDynamicAtlas.h>

Classes
class	Node

Public Types
enum class	InternalMultisample : bool { kNo = false , kYes = true }
enum class	RectanizerAlgorithm { kSkyline , kPow2 }
using	LazyAtlasDesc = GrSurfaceProxy::LazySurfaceDesc
using	LazyInstantiateAtlasCallback = GrSurfaceProxy::LazyInstantiateCallback

Public Member Functions
	GrDynamicAtlas (GrColorType colorType, InternalMultisample, SkISize initialSize, int maxAtlasSize, const GrCaps &, RectanizerAlgorithm=RectanizerAlgorithm::kSkyline)
virtual	~GrDynamicAtlas ()
void	reset (SkISize initialSize, const GrCaps &desc)
GrColorType	colorType () const
int	maxAtlasSize () const
GrTextureProxy *	textureProxy () const
GrSurfaceProxyView	readView (const GrCaps &) const
GrSurfaceProxyView	writeView (const GrCaps &) const
bool	isInstantiated () const
bool	addRect (int width, int height, SkIPoint16 *location)
const SkISize &	drawBounds ()
bool	instantiate (GrOnFlushResourceProvider *, sk_sp< GrTexture > backingTexture=nullptr)

Static Public Member Functions
static sk_sp< GrTextureProxy >	MakeLazyAtlasProxy (LazyInstantiateAtlasCallback &&, GrColorType colorType, InternalMultisample, const GrCaps &, GrSurfaceProxy::UseAllocator)

Static Public Attributes
static constexpr GrSurfaceOrigin	kTextureOrigin = kTopLeft_GrSurfaceOrigin
static constexpr int	kPadding = 1

Detailed Description

This class implements a dynamic size skgpu::Rectanizer that grows until it reaches the implementation-dependent max texture size. When finalized, it also creates and stores a GrTextureProxy for the underlying atlas.

Definition at line 25 of file GrDynamicAtlas.h.

Member Typedef Documentation

LazyAtlasDesc

using GrDynamicAtlas::LazyAtlasDesc = GrSurfaceProxy::LazySurfaceDesc

Definition at line 32 of file GrDynamicAtlas.h.

LazyInstantiateAtlasCallback

using GrDynamicAtlas::LazyInstantiateAtlasCallback = GrSurfaceProxy::LazyInstantiateCallback

Definition at line 33 of file GrDynamicAtlas.h.

Member Enumeration Documentation

InternalMultisample

enum class GrDynamicAtlas::InternalMultisample : bool

strong

Enumerator
kNo
kYes

Definition at line 35 of file GrDynamicAtlas.h.

                                   : bool {
        kNo = false,
        kYes = true
    };

RectanizerAlgorithm

enum class GrDynamicAtlas::RectanizerAlgorithm

strong

Enumerator
kSkyline
kPow2

Definition at line 46 of file GrDynamicAtlas.h.

                                   {
        kSkyline,
        kPow2
    };

Constructor & Destructor Documentation

GrDynamicAtlas()

GrDynamicAtlas::GrDynamicAtlas	(	GrColorType	colorType,
		InternalMultisample	internalMultisample,
		SkISize	initialSize,
		int	maxAtlasSize,
		const GrCaps &	caps,
		RectanizerAlgorithm	algorithm = RectanizerAlgorithm::kSkyline
	)

Definition at line 77 of file GrDynamicAtlas.cpp.

        : fColorType(colorType)
        , fInternalMultisample(internalMultisample)
        , fMaxAtlasSize(maxAtlasSize)
        , fRectanizerAlgorithm(algorithm) {
    SkASSERT(fMaxAtlasSize <= caps.maxTextureSize());
    this->reset(initialSize, caps);
}

~GrDynamicAtlas()

GrDynamicAtlas::~GrDynamicAtlas ( )

virtual

Definition at line 88 of file GrDynamicAtlas.cpp.

                                {
}

Member Function Documentation

addRect()

bool GrDynamicAtlas::addRect	(	int	width,
		int	height,
		SkIPoint16 *	location
	)

Definition at line 136 of file GrDynamicAtlas.cpp.

                                                                        {
    // This can't be called anymore once instantiate() has been called.
    SkASSERT(!this->isInstantiated());
 
    if (!this->internalPlaceRect(width, height, location)) {
        return false;
    }
 
    fDrawBounds.fWidth = std::max(fDrawBounds.width(), location->x() + width);
    fDrawBounds.fHeight = std::max(fDrawBounds.height(), location->y() + height);
    return true;
}

colorType()

GrColorType GrDynamicAtlas::colorType ( ) const

inline

Definition at line 58 of file GrDynamicAtlas.h.

{ return fColorType; }

drawBounds()

const SkISize & GrDynamicAtlas::drawBounds ( )

inline

Definition at line 68 of file GrDynamicAtlas.h.

{ return fDrawBounds; }

instantiate()

bool GrDynamicAtlas::instantiate	(	GrOnFlushResourceProvider *	onFlushRP,
		sk_sp< GrTexture >	backingTexture = nullptr
	)

Definition at line 193 of file GrDynamicAtlas.cpp.

                                                                  {
    SkASSERT(!this->isInstantiated());  // This method should only be called once.
    // Caller should have cropped any paths to the destination render target instead of asking for
    // an atlas larger than maxRenderTargetSize.
    SkASSERT(std::max(fHeight, fWidth) <= fMaxAtlasSize);
    SkASSERT(fMaxAtlasSize <= onFlushRP->caps()->maxRenderTargetSize());
 
    if (fTextureProxy->isFullyLazy()) {
        // Finalize the content size of our proxy. The GPU can potentially make optimizations if it
        // knows we only intend to write out a smaller sub-rectangle of the backing texture.
        fTextureProxy->priv().setLazyDimensions(fDrawBounds);
    }
    SkASSERT(fTextureProxy->dimensions() == fDrawBounds);
 
    if (backingTexture) {
#ifdef SK_DEBUG
        auto backingRT = backingTexture->asRenderTarget();
        SkASSERT(backingRT);
        SkASSERT(backingRT->backendFormat() == fTextureProxy->backendFormat());
        SkASSERT(backingRT->numSamples() == fTextureProxy->asRenderTargetProxy()->numSamples());
        SkASSERT(backingRT->dimensions() == fTextureProxy->backingStoreDimensions());
#endif
        // This works bc 'fTextureProxy' is a lazy proxy and, in its LazyInstantiateAtlasCallback,
        // it will just wrap 'fBackingTexture' if it is non-null.
        fBackingTexture = std::move(backingTexture);
    }
    return onFlushRP->instantiateProxy(fTextureProxy.get());
}

isInstantiated()

bool GrDynamicAtlas::isInstantiated ( ) const

inline

Definition at line 63 of file GrDynamicAtlas.h.

{ return fTextureProxy->isInstantiated(); }

MakeLazyAtlasProxy()

sk_sp< GrTextureProxy > GrDynamicAtlas::MakeLazyAtlasProxy ( LazyInstantiateAtlasCallback &&  callback, GrColorType  colorType, InternalMultisample  internalMultisample, const GrCaps &  caps, GrSurfaceProxy::UseAllocator  useAllocator  )

static

Definition at line 57 of file GrDynamicAtlas.cpp.

                                                 {
    GrBackendFormat format = caps.getDefaultBackendFormat(colorType, GrRenderable::kYes);
 
    int sampleCount = 1;
    if (InternalMultisample::kYes == internalMultisample) {
        sampleCount = caps.internalMultisampleCount(format);
    }
 
    sk_sp<GrTextureProxy> proxy =
            GrProxyProvider::MakeFullyLazyProxy(std::move(callback), format, GrRenderable::kYes,
                                                sampleCount, GrProtected::kNo, caps, useAllocator);
 
    return proxy;
}

maxAtlasSize()

int GrDynamicAtlas::maxAtlasSize ( ) const

inline

Definition at line 59 of file GrDynamicAtlas.h.

{ return fMaxAtlasSize; }

readView()

GrSurfaceProxyView GrDynamicAtlas::readView

(

const GrCaps &

caps

)

const

Definition at line 126 of file GrDynamicAtlas.cpp.

                                                                    {
    return {fTextureProxy, kTextureOrigin,
            caps.getReadSwizzle(fTextureProxy->backendFormat(), fColorType)};
}

reset()

void GrDynamicAtlas::reset	(	SkISize	initialSize,
		const GrCaps &	desc
	)

Definition at line 91 of file GrDynamicAtlas.cpp.

                                                                  {
    fNodeAllocator.reset();
    fWidth = std::min(SkNextPow2(initialSize.width()), fMaxAtlasSize);
    fHeight = std::min(SkNextPow2(initialSize.height()), fMaxAtlasSize);
    fTopNode = nullptr;
    fDrawBounds.setEmpty();
    fTextureProxy = MakeLazyAtlasProxy(
            [this](GrResourceProvider* resourceProvider, const LazyAtlasDesc& desc) {
                if (!fBackingTexture) {
                    fBackingTexture =
                            resourceProvider->createTexture(fTextureProxy->backingStoreDimensions(),
                                                            desc.fFormat,
                                                            desc.fTextureType,
                                                            desc.fRenderable,
                                                            desc.fSampleCnt,
                                                            desc.fMipmapped,
                                                            desc.fBudgeted,
                                                            desc.fProtected,
                                                            desc.fLabel);
                }
                return GrSurfaceProxy::LazyCallbackResult(fBackingTexture);
            },
            fColorType, fInternalMultisample, caps, GrSurfaceProxy::UseAllocator::kNo);
    fBackingTexture = nullptr;
}

textureProxy()

GrTextureProxy * GrDynamicAtlas::textureProxy ( ) const

inline

Definition at line 60 of file GrDynamicAtlas.h.

{ return fTextureProxy.get(); }

writeView()

GrSurfaceProxyView GrDynamicAtlas::writeView

(

const GrCaps &

caps

)

const

Definition at line 131 of file GrDynamicAtlas.cpp.

                                                                     {
    return {fTextureProxy, kTextureOrigin,
            caps.getWriteSwizzle(fTextureProxy->backendFormat(), fColorType)};
}

Member Data Documentation

kPadding

constexpr int GrDynamicAtlas::kPadding = 1

inlinestaticconstexpr

Definition at line 29 of file GrDynamicAtlas.h.

kTextureOrigin

constexpr GrSurfaceOrigin GrDynamicAtlas::kTextureOrigin = kTopLeft_GrSurfaceOrigin

inlinestaticconstexpr

Definition at line 28 of file GrDynamicAtlas.h.

---

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

• third_party/skia/src/gpu/ganesh/GrDynamicAtlas.h
• third_party/skia/src/gpu/ganesh/GrDynamicAtlas.cpp