#include <AtlasProvider.h>

Public Types
enum class	PathAtlasFlags : unsigned { kNone = 0b000 , kCompute = 0b001 , kRaster = 0b010 }

using	PathAtlasFlagsBitMask = SkEnumBitMask< PathAtlasFlags >

Public Member Functions
	AtlasProvider (Recorder *)

	~AtlasProvider ()=default

TextAtlasManager *	textAtlasManager () const

bool	isAvailable (PathAtlasFlags atlasType) const

std::unique_ptr< ComputePathAtlas >	createComputePathAtlas (Recorder *recorder) const

RasterPathAtlas *	getRasterPathAtlas () const

sk_sp< TextureProxy >	getAtlasTexture (Recorder *, uint16_t width, uint16_t height, SkColorType, uint16_t identifier, bool requireStorageUsage)

void	clearTexturePool ()

void	recordUploads (DrawContext *)

void	postFlush ()

Static Public Member Functions
static PathAtlasFlagsBitMask	QueryPathAtlasSupport (const Caps *)

Detailed Description

AtlasProvider groups various texture atlas management algorithms together.

Definition at line 33 of file AtlasProvider.h.

Member Typedef Documentation

◆ PathAtlasFlagsBitMask

using skgpu::graphite::AtlasProvider::PathAtlasFlagsBitMask = SkEnumBitMask<PathAtlasFlags>

Definition at line 43 of file AtlasProvider.h.

Member Enumeration Documentation

◆ PathAtlasFlags

enum class skgpu::graphite::AtlasProvider::PathAtlasFlags : unsigned

strong

Enumerator
kNone
kCompute
kRaster

Definition at line 35 of file AtlasProvider.h.

                              : unsigned {
        kNone    = 0b000,
        // ComputePathAtlas is supported
        kCompute = 0b001,
        // RasterPathAtlas is supported
        kRaster  = 0b010,
    };

Constructor & Destructor Documentation

◆ AtlasProvider()

skgpu::graphite::AtlasProvider::AtlasProvider ( Recorder * recorder )

explicit

Definition at line 31 of file AtlasProvider.cpp.

        : fTextAtlasManager(std::make_unique<TextAtlasManager>(recorder))
        , fRasterPathAtlas(std::make_unique<RasterPathAtlas>(recorder))
        , fPathAtlasFlags(QueryPathAtlasSupport(recorder->priv().caps())) {}

◆ ~AtlasProvider()

skgpu::graphite::AtlasProvider::~AtlasProvider ( )

default

Member Function Documentation

◆ clearTexturePool()

void skgpu::graphite::AtlasProvider::clearTexturePool ( )

Definition at line 86 of file AtlasProvider.cpp.

                                     {
    fTexturePool.clear();
}

◆ createComputePathAtlas()

std::unique_ptr< ComputePathAtlas > skgpu::graphite::AtlasProvider::createComputePathAtlas ( Recorder * recorder ) const

Definition at line 36 of file AtlasProvider.cpp.

                                                                                              {
    if (this->isAvailable(PathAtlasFlags::kCompute)) {
        return ComputePathAtlas::CreateDefault(recorder);
    }
    return nullptr;
}

◆ getAtlasTexture()

sk_sp< TextureProxy > skgpu::graphite::AtlasProvider::getAtlasTexture	(	Recorder *	recorder,
		uint16_t	width,
		uint16_t	height,
		SkColorType	colorType,
		uint16_t	identifier,
		bool	requireStorageUsage
	)

Definition at line 47 of file AtlasProvider.cpp.

                                                                             {
    uint64_t key = static_cast<uint64_t>(width)  << 48 |
                   static_cast<uint64_t>(height) << 32 |
                   static_cast<uint64_t>(colorType) << 16 |
                   static_cast<uint64_t>(identifier);
    auto iter = fTexturePool.find(key);
    if (iter != fTexturePool.end()) {
        return iter->second;
    }
 
    // We currently only make the distinction between a storage texture (written by a
    // compute pass) and a plain sampleable texture (written via upload) that won't be
    // used as a render attachment.
    const Caps* caps = recorder->priv().caps();
    auto textureInfo = requireStorageUsage
            ? caps->getDefaultStorageTextureInfo(colorType)
            : caps->getDefaultSampledTextureInfo(colorType,
                                                 Mipmapped::kNo,
                                                 recorder->priv().isProtected(),
                                                 Renderable::kNo);
    sk_sp<TextureProxy> proxy = TextureProxy::Make(caps,
                                                   recorder->priv().resourceProvider(),
                                                   SkISize::Make((int32_t) width, (int32_t) height),
                                                   textureInfo,
                                                   "AtlasProviderTexture",
                                                   Budgeted::kYes);
    if (!proxy) {
        return nullptr;
    }
 
    fTexturePool[key] = proxy;
    return proxy;
}

◆ getRasterPathAtlas()

RasterPathAtlas * skgpu::graphite::AtlasProvider::getRasterPathAtlas ( ) const

Definition at line 43 of file AtlasProvider.cpp.

                                                         {
    return fRasterPathAtlas.get();
}

◆ isAvailable()

bool skgpu::graphite::AtlasProvider::isAvailable ( PathAtlasFlags atlasType ) const

inline

Definition at line 57 of file AtlasProvider.h.

                                                     {
        return SkToBool(fPathAtlasFlags & atlasType);
    }

◆ postFlush()

void skgpu::graphite::AtlasProvider::postFlush ( )

Definition at line 100 of file AtlasProvider.cpp.

                              {
    fTextAtlasManager->postFlush();
    if (fRasterPathAtlas) {
        fRasterPathAtlas->postFlush();
    }
}

◆ QueryPathAtlasSupport()

AtlasProvider::PathAtlasFlagsBitMask skgpu::graphite::AtlasProvider::QueryPathAtlasSupport ( const Caps * caps )

static

Definition at line 22 of file AtlasProvider.cpp.

                                                                                        {
    // The raster-backend path atlas is always supported.
    PathAtlasFlagsBitMask flags = PathAtlasFlags::kRaster;
    if (RendererProvider::IsVelloRendererSupported(caps)) {
        flags |= PathAtlasFlags::kCompute;
    }
    return flags;
}

◆ recordUploads()

void skgpu::graphite::AtlasProvider::recordUploads ( DrawContext * dc )

Definition at line 90 of file AtlasProvider.cpp.

                                                 {
    if (!fTextAtlasManager->recordUploads(dc)) {
        SKGPU_LOG_E("TextAtlasManager uploads have failed -- may see invalid results.");
    }
 
    if (fRasterPathAtlas) {
        fRasterPathAtlas->recordUploads(dc);
    }
}

◆ textAtlasManager()

TextAtlasManager * skgpu::graphite::AtlasProvider::textAtlasManager ( ) const