GrResourceProvider Class Reference

#include <GrResourceProvider.h>

Public Types
enum class	ZeroInit : bool { kNo = false , kYes = true }
using	InitializeBufferFn = void(*)(skgpu::VertexWriter, size_t bufferSize)

Public Member Functions
	GrResourceProvider (GrGpu *, GrResourceCache *, skgpu::SingleOwner *)
template<typename T = GrGpuResource>
std::enable_if< std::is_base_of< GrGpuResource, T >::value, sk_sp< T > >::type	findByUniqueKey (const skgpu::UniqueKey &key)
sk_sp< GrTexture >	createApproxTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, skgpu::Renderable renderable, int renderTargetSampleCnt, skgpu::Protected isProtected, std::string_view label)
sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, skgpu::Renderable renderable, int renderTargetSampleCnt, skgpu::Mipmapped mipmapped, skgpu::Budgeted budgeted, skgpu::Protected isProtected, std::string_view label)
sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrColorType colorType, skgpu::Renderable renderable, int renderTargetSampleCnt, skgpu::Budgeted budgeted, skgpu::Mipmapped mipmapped, skgpu::Protected isProtected, const GrMipLevel texels[], std::string_view label)
sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &, GrTextureType textureType, GrColorType srcColorType, skgpu::Renderable, int renderTargetSampleCnt, skgpu::Budgeted, SkBackingFit, skgpu::Protected, const GrMipLevel &mipLevel, std::string_view label)
sk_sp< GrTexture >	findAndRefScratchTexture (const skgpu::ScratchKey &, std::string_view label)
sk_sp< GrTexture >	findAndRefScratchTexture (SkISize dimensions, const GrBackendFormat &, GrTextureType textureType, skgpu::Renderable, int renderTargetSampleCnt, skgpu::Mipmapped, skgpu::Protected, std::string_view label)
sk_sp< GrTexture >	createCompressedTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Budgeted, skgpu::Mipmapped, skgpu::Protected, SkData *data, std::string_view label)
sk_sp< GrTexture >	wrapBackendTexture (const GrBackendTexture &tex, GrWrapOwnership, GrWrapCacheable, GrIOType)
sk_sp< GrTexture >	wrapCompressedBackendTexture (const GrBackendTexture &tex, GrWrapOwnership, GrWrapCacheable)
sk_sp< GrTexture >	wrapRenderableBackendTexture (const GrBackendTexture &tex, int sampleCnt, GrWrapOwnership, GrWrapCacheable)
sk_sp< GrRenderTarget >	wrapBackendRenderTarget (const GrBackendRenderTarget &)
sk_sp< GrRenderTarget >	wrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)
sk_sp< const GrGpuBuffer >	findOrMakeStaticBuffer (GrGpuBufferType intendedType, size_t size, const skgpu::UniqueKey &key, InitializeBufferFn)
sk_sp< const GrGpuBuffer >	findOrMakeStaticBuffer (GrGpuBufferType intendedType, size_t size, const void *staticData, const skgpu::UniqueKey &key)
sk_sp< const GrGpuBuffer >	findOrCreatePatternedIndexBuffer (const uint16_t *pattern, int patternSize, int reps, int vertCount, const skgpu::UniqueKey &key)
sk_sp< const GrGpuBuffer >	refNonAAQuadIndexBuffer ()
sk_sp< const GrGpuBuffer >	refAAQuadIndexBuffer ()
sk_sp< GrGpuBuffer >	createBuffer (size_t size, GrGpuBufferType, GrAccessPattern, ZeroInit)
sk_sp< GrGpuBuffer >	createBuffer (const void *data, size_t size, GrGpuBufferType type, GrAccessPattern pattern)
bool	attachStencilAttachment (GrRenderTarget *rt, bool useMSAASurface)
sk_sp< GrAttachment >	makeMSAAAttachment (SkISize dimensions, const GrBackendFormat &format, int sampleCnt, skgpu::Protected isProtected, GrMemoryless isMemoryless)
sk_sp< GrAttachment >	getDiscardableMSAAAttachment (SkISize dimensions, const GrBackendFormat &format, int sampleCnt, skgpu::Protected isProtected, GrMemoryless memoryless)
void	assignUniqueKeyToResource (const skgpu::UniqueKey &, GrGpuResource *)
std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned=true)
std::unique_ptr< GrSemaphore >	wrapBackendSemaphore (const GrBackendSemaphore &, GrSemaphoreWrapType, GrWrapOwnership=kBorrow_GrWrapOwnership)
void	abandon ()
uint32_t	contextUniqueID () const
const GrCaps *	caps () const
bool	overBudget () const
GrResourceProviderPriv	priv ()
const GrResourceProviderPriv	priv () const

Static Public Member Functions
static int	MaxNumNonAAQuads ()
static int	NumVertsPerNonAAQuad ()
static int	NumIndicesPerNonAAQuad ()
static int	MaxNumAAQuads ()
static int	NumVertsPerAAQuad ()
static int	NumIndicesPerAAQuad ()

Friends
class	GrResourceProviderPriv

Detailed Description

A factory for arbitrary resource types.

Definition at line 59 of file GrResourceProvider.h.

Member Typedef Documentation

InitializeBufferFn

using GrResourceProvider::InitializeBufferFn = void(*)(skgpu::VertexWriter, size_t bufferSize)

Either finds and refs a buffer with the given unique key, or creates a new new, fills its contents with the InitializeBufferDataFn() callback, and assigns it the unique key.

Parameters

intendedType	hint to the graphics subsystem about how the buffer will be used.
size	minimum size of buffer to return.
key	Key to be assigned to the buffer.
InitializeBufferFn	callback with which to initialize the buffer.

Returns

The buffer if successful, otherwise nullptr.

Definition at line 220 of file GrResourceProvider.h.

Member Enumeration Documentation

ZeroInit

enum class GrResourceProvider::ZeroInit : bool

strong

Enumerator
kNo
kYes

Definition at line 301 of file GrResourceProvider.h.

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

Constructor & Destructor Documentation

GrResourceProvider()

GrResourceProvider::GrResourceProvider	(	GrGpu *	gpu,
		GrResourceCache *	cache,
		skgpu::SingleOwner *	owner
	)

Definition at line 48 of file GrResourceProvider.cpp.

        : fCache(cache)
        , fGpu(gpu)
#ifdef SK_DEBUG
        , fSingleOwner(owner)
#endif
{
    fCaps = sk_ref_sp(fGpu->caps());
}

Member Function Documentation

abandon()

void GrResourceProvider::abandon ( )

inline

Definition at line 357 of file GrResourceProvider.h.

                   {
        fCache = nullptr;
        fGpu = nullptr;
    }

assignUniqueKeyToResource()

void GrResourceProvider::assignUniqueKeyToResource	(	const skgpu::UniqueKey &	key,
		GrGpuResource *	resource
	)

Assigns a unique key to a resource. If the key is associated with another resource that association is removed and replaced by this resource.

Definition at line 423 of file GrResourceProvider.cpp.

                                                                            {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned() || !resource) {
        return;
    }
    resource->resourcePriv().setUniqueKey(key);
}

attachStencilAttachment()

bool GrResourceProvider::attachStencilAttachment	(	GrRenderTarget *	rt,
		bool	useMSAASurface
	)

If passed in render target already has a stencil buffer on the specified surface, return true. Otherwise attempt to attach one and return true on success.

Definition at line 664 of file GrResourceProvider.cpp.

                                                                                        {
    SkASSERT(rt);
    SkASSERT(!this->caps()->avoidStencilBuffers());
 
    GrAttachment* stencil = rt->getStencilAttachment(useMSAASurface);
    if (stencil) {
        SkASSERT(stencil->numSamples() == num_stencil_samples(rt, useMSAASurface, *this->caps()));
        return true;
    }
 
    if (!rt->wasDestroyed() && rt->canAttemptStencilAttachment(useMSAASurface)) {
        skgpu::UniqueKey sbKey;
 
#if 0
        if (this->caps()->oversizedStencilSupport()) {
            width  = SkNextPow2(width);
            height = SkNextPow2(height);
        }
#endif
        GrBackendFormat stencilFormat = this->gpu()->getPreferredStencilFormat(rt->backendFormat());
        if (!stencilFormat.isValid()) {
            return false;
        }
        GrProtected isProtected = rt->isProtected() ? GrProtected::kYes : GrProtected::kNo;
        int numStencilSamples = num_stencil_samples(rt, useMSAASurface, *this->caps());
        GrAttachment::ComputeSharedAttachmentUniqueKey(*this->caps(),
                                                       stencilFormat,
                                                       rt->dimensions(),
                                                       GrAttachment::UsageFlags::kStencilAttachment,
                                                       numStencilSamples,
                                                       skgpu::Mipmapped::kNo,
                                                       isProtected,
                                                       GrMemoryless::kNo,
                                                       &sbKey);
        auto keyedStencil = this->findByUniqueKey<GrAttachment>(sbKey);
        if (!keyedStencil) {
            // Need to try and create a new stencil
            keyedStencil = this->gpu()->makeStencilAttachment(rt->backendFormat(), rt->dimensions(),
                                                              numStencilSamples);
            if (!keyedStencil) {
                return false;
            }
            this->assignUniqueKeyToResource(sbKey, keyedStencil.get());
        }
        rt->attachStencilAttachment(std::move(keyedStencil), useMSAASurface);
    }
    stencil = rt->getStencilAttachment(useMSAASurface);
    SkASSERT(!stencil ||
             stencil->numSamples() == num_stencil_samples(rt, useMSAASurface, *this->caps()));
    return stencil != nullptr;
}

caps()

const GrCaps * GrResourceProvider::caps ( ) const

inline

Definition at line 363 of file GrResourceProvider.h.

{ return fCaps.get(); }

contextUniqueID()

uint32_t GrResourceProvider::contextUniqueID ( ) const

inline

Definition at line 362 of file GrResourceProvider.h.

{ return fCache->contextUniqueID(); }

createApproxTexture()

sk_sp< GrTexture > GrResourceProvider::createApproxTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		skgpu::Renderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Protected	isProtected,
		std::string_view	label
	)

Finds a texture that approximately matches the descriptor. Will be at least as large in width and height as desc specifies. If renderable is kYes then the GrTexture will also be a GrRenderTarget. The texture's format and sample count will always match the request. The contents of the texture are undefined.

Definition at line 280 of file GrResourceProvider.cpp.

                                                                               {
    ASSERT_SINGLE_OWNER
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    // Currently we don't recycle compressed textures as scratch. Additionally all compressed
    // textures should be created through the createCompressedTexture function.
    SkASSERT(!this->caps()->isFormatCompressed(format));
 
    if (!fCaps->validateSurfaceParams(dimensions,
                                      format,
                                      renderable,
                                      renderTargetSampleCnt,
                                      skgpu::Mipmapped::kNo,
                                      textureType)) {
        return nullptr;
    }
 
    auto copyDimensions = skgpu::GetApproxSize(dimensions);
 
    if (auto tex = this->findAndRefScratchTexture(copyDimensions,
                                                  format,
                                                  textureType,
                                                  renderable,
                                                  renderTargetSampleCnt,
                                                  skgpu::Mipmapped::kNo,
                                                  isProtected,
                                                  label)) {
        return tex;
    }
 
    return fGpu->createTexture(copyDimensions,
                               format,
                               textureType,
                               renderable,
                               renderTargetSampleCnt,
                               skgpu::Mipmapped::kNo,
                               skgpu::Budgeted::kYes,
                               isProtected,
                               label);
}

createBuffer() [1/2]

sk_sp< GrGpuBuffer > GrResourceProvider::createBuffer	(	const void *	data,
		size_t	size,
		GrGpuBufferType	type,
		GrAccessPattern	pattern
	)

Same as above but also fills the buffer from data.

Definition at line 640 of file GrResourceProvider.cpp.

                                                                             {
    SkASSERT(data);
    auto buffer = this->createBuffer(size, type, pattern, ZeroInit::kNo);
    if (!buffer) {
        return nullptr;
    }
    if (!buffer->updateData(data, /*offset=*/0, size, /*preserve=*/false)) {
        return nullptr;
    }
    return buffer;
}

createBuffer() [2/2]

sk_sp< GrGpuBuffer > GrResourceProvider::createBuffer	(	size_t	size,
		GrGpuBufferType	intendedType,
		GrAccessPattern	accessPattern,
		ZeroInit	zeroInit
	)

Returns a buffer.

Parameters

size	minimum size of buffer to return.
GrGpuBufferType	hint to the graphics subsystem about what the buffer will be used for.
GrAccessPattern	hint to the graphics subsystem about how the data will be accessed.
ZeroInit	if kYes zero-initialize the buffer. Otherwise, contents are undefined.

Returns

the buffer if successful, otherwise nullptr.

Definition at line 596 of file GrResourceProvider.cpp.

                                                                       {
    if (this->isAbandoned()) {
        return nullptr;
    }
    if (kDynamic_GrAccessPattern != accessPattern) {
        if (this->caps()->buffersAreInitiallyZero()) {
            zeroInit = ZeroInit::kNo;
        }
        sk_sp<GrGpuBuffer> buffer = this->gpu()->createBuffer(size, intendedType, accessPattern);
        if (buffer && zeroInit == ZeroInit::kYes && !buffer->clearToZero()) {
            return nullptr;
        }
        return buffer;
    }
    // bin by pow2+midpoint with a reasonable min
    static const size_t MIN_SIZE = 1 << 12;
    static const size_t MIN_UNIFORM_SIZE = 1 << 7;
    size_t allocSize = intendedType == GrGpuBufferType::kUniform ? std::max(size, MIN_UNIFORM_SIZE)
                                                                 : std::max(size, MIN_SIZE);
    size_t ceilPow2 = GrNextSizePow2(allocSize);
    size_t floorPow2 = ceilPow2 >> 1;
    size_t mid = floorPow2 + (floorPow2 >> 1);
    allocSize = (allocSize <= mid) ? mid : ceilPow2;
 
    skgpu::ScratchKey key;
    GrGpuBuffer::ComputeScratchKeyForDynamicBuffer(allocSize, intendedType, &key);
    auto buffer =
            sk_sp<GrGpuBuffer>(static_cast<GrGpuBuffer*>(this->cache()->findAndRefScratchResource(
                    key)));
    if (!buffer) {
        if (this->caps()->buffersAreInitiallyZero()) {
            zeroInit = ZeroInit::kNo;
        }
        buffer = this->gpu()->createBuffer(allocSize, intendedType, kDynamic_GrAccessPattern);
    }
    if (buffer && zeroInit == ZeroInit::kYes && !buffer->clearToZero()) {
        return nullptr;
    }
    return buffer;
}

createCompressedTexture()

sk_sp< GrTexture > GrResourceProvider::createCompressedTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		skgpu::Budgeted	budgeted,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		SkData *	data,
		std::string_view	label
	)

Creates a compressed texture. The GrGpu must support the SkImageImage::Compression type. It will not be renderable.

Definition at line 211 of file GrResourceProvider.cpp.

                                                                                   {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
    return fGpu->createCompressedTexture(dimensions,
                                         format,
                                         budgeted,
                                         mipmapped,
                                         isProtected,
                                         data->data(),
                                         data->size());
}

createTexture() [1/3]

sk_sp< GrTexture > GrResourceProvider::createTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		GrColorType	srcColorType,
		skgpu::Renderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		SkBackingFit	fit,
		skgpu::Protected	isProtected,
		const GrMipLevel &	mipLevel,
		std::string_view	label
	)

Create a potentially loose fit texture with the provided data. The color type must be valid for the format and also describe the texel data. This will ensure any conversions that need to get applied to the data before upload are applied.

Definition at line 155 of file GrResourceProvider.cpp.

                                                                         {
    ASSERT_SINGLE_OWNER
 
    if (!mipLevel.fPixels) {
        return nullptr;
    }
 
    if (SkBackingFit::kApprox == fit) {
        if (this->isAbandoned()) {
            return nullptr;
        }
        if (!fCaps->validateSurfaceParams(dimensions,
                                          format,
                                          renderable,
                                          renderTargetSampleCnt,
                                          skgpu::Mipmapped::kNo,
                                          textureType)) {
            return nullptr;
        }
 
        auto tex = this->createApproxTexture(dimensions,
                                             format,
                                             textureType,
                                             renderable,
                                             renderTargetSampleCnt,
                                             isProtected,
                                             label);
        if (!tex) {
            return nullptr;
        }
        return this->writePixels(std::move(tex), colorType, dimensions, &mipLevel, 1);
    } else {
        return this->createTexture(dimensions,
                                   format,
                                   textureType,
                                   colorType,
                                   renderable,
                                   renderTargetSampleCnt,
                                   budgeted,
                                   skgpu::Mipmapped::kNo,
                                   isProtected,
                                   &mipLevel,
                                   label);
    }
}

createTexture() [2/3]

sk_sp< GrTexture > GrResourceProvider::createTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		GrColorType	colorType,
		skgpu::Renderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		const GrMipLevel	texels[],
		std::string_view	label
	)

Create an exact fit texture with initial data to upload. The color type must be valid for the format and also describe the texel data. This will ensure any conversions that need to get applied to the data before upload are applied.

Definition at line 60 of file GrResourceProvider.cpp.

                                                                         {
    ASSERT_SINGLE_OWNER
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    int numMipLevels = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.fWidth, dimensions.fHeight) + 1;
    }
 
    if (!fCaps->validateSurfaceParams(dimensions,
                                      format,
                                      renderable,
                                      renderTargetSampleCnt,
                                      mipmapped,
                                      textureType)) {
        return nullptr;
    }
    // Current rule is that you can provide no level data, just the base, or all the levels.
    bool hasPixels = texels[0].fPixels;
    auto scratch = this->getExactScratch(dimensions,
                                         format,
                                         textureType,
                                         renderable,
                                         renderTargetSampleCnt,
                                         budgeted,
                                         mipmapped,
                                         isProtected,
                                         label);
    if (scratch) {
        if (!hasPixels) {
            return scratch;
        }
        return this->writePixels(std::move(scratch), colorType, dimensions, texels, numMipLevels);
    }
    AutoSTArray<14, GrMipLevel> tmpTexels;
    AutoSTArray<14, std::unique_ptr<char[]>> tmpDatas;
    GrColorType tempColorType = GrColorType::kUnknown;
    if (hasPixels) {
        tempColorType = this->prepareLevels(format, colorType, dimensions, texels, numMipLevels,
                                            &tmpTexels, &tmpDatas);
        if (tempColorType == GrColorType::kUnknown) {
            return nullptr;
        }
    }
    return fGpu->createTexture(dimensions,
                               format,
                               textureType,
                               renderable,
                               renderTargetSampleCnt,
                               budgeted,
                               isProtected,
                               colorType,
                               tempColorType,
                               tmpTexels.get(),
                               numMipLevels,
                               label);
}

createTexture() [3/3]

sk_sp< GrTexture > GrResourceProvider::createTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		skgpu::Renderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Mipmapped	mipmapped,
		skgpu::Budgeted	budgeted,
		skgpu::Protected	isProtected,
		std::string_view	label
	)

Create an exact fit texture with no initial data to upload.

Definition at line 231 of file GrResourceProvider.cpp.

                                                                         {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    if (!fCaps->validateSurfaceParams(dimensions, format, renderable, renderTargetSampleCnt,
                                      mipmapped, textureType)) {
        return nullptr;
    }
 
    // Currently we don't recycle compressed textures as scratch. Additionally all compressed
    // textures should be created through the createCompressedTexture function.
    SkASSERT(!this->caps()->isFormatCompressed(format));
 
    // TODO: Support skgpu::Mipmapped::kYes in scratch texture lookup here.
    sk_sp<GrTexture> tex =
            this->getExactScratch(dimensions,
                                  format,
                                  textureType,
                                  renderable,
                                  renderTargetSampleCnt,
                                  budgeted,
                                  mipmapped,
                                  isProtected,
                                  label);
    if (tex) {
        return tex;
    }
 
    return fGpu->createTexture(dimensions,
                               format,
                               textureType,
                               renderable,
                               renderTargetSampleCnt,
                               mipmapped,
                               budgeted,
                               isProtected,
                               label);
}

findAndRefScratchTexture() [1/2]

sk_sp< GrTexture > GrResourceProvider::findAndRefScratchTexture	(	const skgpu::ScratchKey &	key,
		std::string_view	label
	)

Search the cache for a scratch texture matching the provided arguments. Failing that it returns null. If non-null, the resulting texture is always budgeted.

Definition at line 330 of file GrResourceProvider.cpp.

                                                                                    {
    ASSERT_SINGLE_OWNER
    SkASSERT(!this->isAbandoned());
    SkASSERT(key.isValid());
 
    if (GrGpuResource* resource = fCache->findAndRefScratchResource(key)) {
        fGpu->stats()->incNumScratchTexturesReused();
        GrSurface* surface = static_cast<GrSurface*>(resource);
        resource->setLabel(std::move(label));
        return sk_sp<GrTexture>(surface->asTexture());
    }
    return nullptr;
}

findAndRefScratchTexture() [2/2]

sk_sp< GrTexture > GrResourceProvider::findAndRefScratchTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		skgpu::Renderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		std::string_view	label
	)

Definition at line 345 of file GrResourceProvider.cpp.

                                                                                    {
    ASSERT_SINGLE_OWNER
    SkASSERT(!this->isAbandoned());
    SkASSERT(!this->caps()->isFormatCompressed(format));
    SkASSERT(fCaps->validateSurfaceParams(dimensions,
                                          format,
                                          renderable,
                                          renderTargetSampleCnt,
                                          skgpu::Mipmapped::kNo,
                                          textureType));
 
    // We could make initial clears work with scratch textures but it is a rare case so we just opt
    // to fall back to making a new texture.
    if (fGpu->caps()->reuseScratchTextures() || renderable == GrRenderable::kYes) {
        skgpu::ScratchKey key;
        GrTexture::ComputeScratchKey(*this->caps(), format, dimensions, renderable,
                                     renderTargetSampleCnt, mipmapped, isProtected, &key);
        return this->findAndRefScratchTexture(key, label);
    }
 
    return nullptr;
}

findByUniqueKey()

template<typename T = GrGpuResource>

std::enable_if< std::is_base_of< GrGpuResource, T >::value, sk_sp< T > >::type GrResourceProvider::findByUniqueKey ( const skgpu::UniqueKey &  key )

inline

Finds a resource in the cache, based on the specified key. Prior to calling this, the caller must be sure that if a resource of exists in the cache with the given unique key then it is of type T.

Definition at line 70 of file GrResourceProvider.h.

                                               {
        return sk_sp<T>(static_cast<T*>(this->findResourceByUniqueKey(key).release()));
    }

findOrCreatePatternedIndexBuffer()

sk_sp< const GrGpuBuffer > GrResourceProvider::findOrCreatePatternedIndexBuffer ( const uint16_t *  pattern, int  patternSize, int  reps, int  vertCount, const skgpu::UniqueKey &  key  )

inline

Either finds and refs, or creates an index buffer with a repeating pattern for drawing contiguous vertices of a repeated mesh. If the return is non-null, the caller owns a ref on the returned GrBuffer.

Parameters

pattern	the pattern of indices to repeat
patternSize	size in bytes of the pattern
reps	number of times to repeat the pattern
vertCount	number of vertices the pattern references
key	Key to be assigned to the index buffer.

Returns

The index buffer if successful, otherwise nullptr.

Definition at line 254 of file GrResourceProvider.h.

                                                                                         {
        if (auto buffer = this->findByUniqueKey<const GrGpuBuffer>(key)) {
            return buffer;
        }
        return this->createPatternedIndexBuffer(pattern, patternSize, reps, vertCount, &key);
    }

findOrMakeStaticBuffer() [1/2]

sk_sp< const GrGpuBuffer > GrResourceProvider::findOrMakeStaticBuffer	(	GrGpuBufferType	intendedType,
		size_t	size,
		const skgpu::UniqueKey &	key,
		InitializeBufferFn	initializeBufferFn
	)

Definition at line 460 of file GrResourceProvider.cpp.

                                               {
    if (auto buffer = this->findByUniqueKey<GrGpuBuffer>(uniqueKey)) {
        return buffer;
    }
 
    auto buffer = this->createBuffer(size,
                                     intendedType,
                                     kStatic_GrAccessPattern,
                                     ZeroInit::kNo);
    if (!buffer) {
        return nullptr;
    }
 
    // We shouldn't bin and/or cache static buffers.
    SkASSERT(buffer->size() == size);
    SkASSERT(!buffer->resourcePriv().getScratchKey().isValid());
 
    buffer->resourcePriv().setUniqueKey(uniqueKey);
 
    // Map the buffer. Use a staging buffer on the heap if mapping isn't supported.
    skgpu::VertexWriter vertexWriter = {buffer->map(), size};
    AutoTMalloc<char> stagingBuffer;
    if (!vertexWriter) {
        SkASSERT(!buffer->isMapped());
        vertexWriter = {stagingBuffer.reset(size), size};
    }
 
    initializeBufferFn(std::move(vertexWriter), size);
 
    if (buffer->isMapped()) {
        buffer->unmap();
    } else {
        buffer->updateData(stagingBuffer, /*offset=*/0, size, /*preserve=*/false);
    }
 
    return buffer;
}

findOrMakeStaticBuffer() [2/2]

sk_sp< const GrGpuBuffer > GrResourceProvider::findOrMakeStaticBuffer	(	GrGpuBufferType	intendedType,
		size_t	size,
		const void *	staticData,
		const skgpu::UniqueKey &	key
	)

Either finds and refs, or creates a static buffer with the given parameters and contents.

Parameters

intendedType	hint to the graphics subsystem about what the buffer will be used for.
size	minimum size of buffer to return.
data	optional data with which to initialize the buffer.
key	Key to be assigned to the buffer.

Returns

The buffer if successful, otherwise nullptr.

Definition at line 438 of file GrResourceProvider.cpp.

                                                                                               {
    if (auto buffer = this->findByUniqueKey<GrGpuBuffer>(key)) {
        return buffer;
    }
 
    auto buffer = this->createBuffer(staticData, size, intendedType, kStatic_GrAccessPattern);
    if (!buffer) {
        return nullptr;
    }
 
    // We shouldn't bin and/or cache static buffers.
    SkASSERT(buffer->size() == size);
    SkASSERT(!buffer->resourcePriv().getScratchKey().isValid());
 
    buffer->resourcePriv().setUniqueKey(key);
 
    return buffer;
}

getDiscardableMSAAAttachment()

sk_sp< GrAttachment > GrResourceProvider::getDiscardableMSAAAttachment	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		int	sampleCnt,
		skgpu::Protected	isProtected,
		GrMemoryless	memoryless
	)

Gets a GrAttachment that can be used for MSAA rendering. This attachment may be shared by other users. Thus any renderpass that uses the attachment should not assume any specific data at the start and should not try to save written data at the end. Ideally the render pass should discard the data at the end.

Definition at line 716 of file GrResourceProvider.cpp.

                                                                                              {
    ASSERT_SINGLE_OWNER
 
    SkASSERT(sampleCnt > 1);
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    if (!fCaps->validateSurfaceParams(dimensions,
                                      format,
                                      GrRenderable::kYes,
                                      sampleCnt,
                                      skgpu::Mipmapped::kNo,
                                      GrTextureType::kNone)) {
        return nullptr;
    }
 
    skgpu::UniqueKey key;
    GrAttachment::ComputeSharedAttachmentUniqueKey(*this->caps(),
                                                   format,
                                                   dimensions,
                                                   GrAttachment::UsageFlags::kColorAttachment,
                                                   sampleCnt,
                                                   skgpu::Mipmapped::kNo,
                                                   isProtected,
                                                   memoryless,
                                                   &key);
    auto msaaAttachment = this->findByUniqueKey<GrAttachment>(key);
    if (msaaAttachment) {
        return msaaAttachment;
    }
    msaaAttachment = this->makeMSAAAttachment(dimensions, format, sampleCnt, isProtected,
                                              memoryless);
    if (msaaAttachment) {
        this->assignUniqueKeyToResource(key, msaaAttachment.get());
    }
    return msaaAttachment;
}

makeMSAAAttachment()

sk_sp< GrAttachment > GrResourceProvider::makeMSAAAttachment	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		int	sampleCnt,
		skgpu::Protected	isProtected,
		GrMemoryless	isMemoryless
	)

Definition at line 760 of file GrResourceProvider.cpp.

                                                                                    {
    ASSERT_SINGLE_OWNER
 
    SkASSERT(sampleCnt > 1);
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    if (!fCaps->validateSurfaceParams(dimensions,
                                      format,
                                      GrRenderable::kYes,
                                      sampleCnt,
                                      skgpu::Mipmapped::kNo,
                                      GrTextureType::kNone)) {
        return nullptr;
    }
 
    auto scratch = this->refScratchMSAAAttachment(dimensions,
                                                  format,
                                                  sampleCnt,
                                                  isProtected,
                                                  memoryless,
                                                  /*label=*/"MakeMSAAAttachment");
    if (scratch) {
        return scratch;
    }
 
    return fGpu->makeMSAAAttachment(dimensions, format, sampleCnt, isProtected, memoryless);
}

makeSemaphore()

std::unique_ptr< GrSemaphore > GrResourceProvider::makeSemaphore

(

bool

isOwned = true

)

Definition at line 832 of file GrResourceProvider.cpp.

                                                                                       {
    return this->isAbandoned() ? nullptr : fGpu->makeSemaphore(isOwned);
}

MaxNumAAQuads()

int GrResourceProvider::MaxNumAAQuads ( )

static

Definition at line 590 of file GrResourceProvider.cpp.

{ return kMaxNumAAQuads; }

MaxNumNonAAQuads()

int GrResourceProvider::MaxNumNonAAQuads ( )

static

Definition at line 562 of file GrResourceProvider.cpp.

{ return kMaxNumNonAAQuads; }

NumIndicesPerAAQuad()

int GrResourceProvider::NumIndicesPerAAQuad ( )

static

Definition at line 592 of file GrResourceProvider.cpp.

{ return kIndicesPerAAQuad; }

NumIndicesPerNonAAQuad()

int GrResourceProvider::NumIndicesPerNonAAQuad ( )

static

Definition at line 564 of file GrResourceProvider.cpp.

{ return kIndicesPerNonAAQuad; }

NumVertsPerAAQuad()

int GrResourceProvider::NumVertsPerAAQuad ( )

static

Definition at line 591 of file GrResourceProvider.cpp.

{ return kVertsPerAAQuad; }

NumVertsPerNonAAQuad()

int GrResourceProvider::NumVertsPerNonAAQuad ( )

static

Definition at line 563 of file GrResourceProvider.cpp.

{ return kVertsPerNonAAQuad; }

overBudget()

bool GrResourceProvider::overBudget ( ) const

inline

Definition at line 364 of file GrResourceProvider.h.

{ return fCache->overBudget(); }

priv() [1/2]

GrResourceProviderPriv GrResourceProvider::priv ( )

inline

Definition at line 32 of file GrResourceProviderPriv.h.

{ return GrResourceProviderPriv(this); }

priv() [2/2]

const GrResourceProviderPriv GrResourceProvider::priv ( ) const

inline

Definition at line 34 of file GrResourceProviderPriv.h.

                                                                   {  // NOLINT(readability-const-return-type)
    return GrResourceProviderPriv(const_cast<GrResourceProvider*>(this));
}

refAAQuadIndexBuffer()

sk_sp< const GrGpuBuffer > GrResourceProvider::refAAQuadIndexBuffer ( )

inline

Returns an index buffer that can be used to render antialiased quads. Each quad consumes 30 indices and 8 vertices. Call MaxNumAAQuads to get the max allowed number of AA quads. Draw with GrPrimitiveType::kTriangles @ return the AA quad index buffer

Definition at line 290 of file GrResourceProvider.h.

                                                    {
        if (!fAAQuadIndexBuffer) {
            fAAQuadIndexBuffer = this->createAAQuadIndexBuffer();
        }
        return fAAQuadIndexBuffer;
    }

refNonAAQuadIndexBuffer()

sk_sp< const GrGpuBuffer > GrResourceProvider::refNonAAQuadIndexBuffer ( )

inline

Returns an index buffer that can be used to render non-antialiased quads. Each quad consumes 6 indices (0, 1, 2, 2, 1, 3) and 4 vertices. Call MaxNumNonAAQuads to get the max allowed number of non-AA quads. Draw with GrPrimitiveType::kTriangles @ return the non-AA quad index buffer

Definition at line 272 of file GrResourceProvider.h.

                                                       {
        if (!fNonAAQuadIndexBuffer) {
            fNonAAQuadIndexBuffer = this->createNonAAQuadIndexBuffer();
        }
        return fNonAAQuadIndexBuffer;
    }

wrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrResourceProvider::wrapBackendRenderTarget

(

const GrBackendRenderTarget &

backendRT

)

Wraps an existing render target with a GrRenderTarget object. It is similar to wrapBackendTexture but can be used to draw into surfaces that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that the client will resolve to a texture). Currently wrapped render targets always use the kBorrow_GrWrapOwnership and GrWrapCacheable::kNo semantics.

Returns

GrRenderTarget object or NULL on failure.

Definition at line 409 of file GrResourceProvider.cpp.

                                                {
    ASSERT_SINGLE_OWNER
    return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT);
}

wrapBackendSemaphore()

std::unique_ptr< GrSemaphore > GrResourceProvider::wrapBackendSemaphore	(	const GrBackendSemaphore &	semaphore,
		GrSemaphoreWrapType	wrapType,
		GrWrapOwnership	ownership = kBorrow_GrWrapOwnership
	)

Definition at line 836 of file GrResourceProvider.cpp.

                                   {
    ASSERT_SINGLE_OWNER
    return this->isAbandoned() ? nullptr : fGpu->wrapBackendSemaphore(semaphore,
                                                                      wrapType,
                                                                      ownership);
}

wrapBackendTexture()

sk_sp< GrTexture > GrResourceProvider::wrapBackendTexture	(	const GrBackendTexture &	tex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		GrIOType	ioType
	)

Wraps an existing texture with a GrTexture object.

GrIOType must either be kRead or kRW. kRead blocks any operations that would modify the pixels (e.g. dst for a copy, regenerating MIP levels, write pixels).

OpenGL: if the object is a texture Gr may change its GL texture params when it is drawn.

Returns

GrTexture object or NULL on failure.

Definition at line 375 of file GrResourceProvider.cpp.

                                                                         {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
    return fGpu->wrapBackendTexture(tex, ownership, cacheable, ioType);
}

wrapCompressedBackendTexture()

sk_sp< GrTexture > GrResourceProvider::wrapCompressedBackendTexture	(	const GrBackendTexture &	tex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable
	)

Definition at line 386 of file GrResourceProvider.cpp.

                                                                                             {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    return fGpu->wrapCompressedBackendTexture(tex, ownership, cacheable);
}

wrapRenderableBackendTexture()

sk_sp< GrTexture > GrResourceProvider::wrapRenderableBackendTexture	(	const GrBackendTexture &	tex,
		int	sampleCnt,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable
	)

This makes the backend texture be renderable. If sampleCnt is > 1 and the underlying API uses separate MSAA render buffers then a MSAA render buffer is created that resolves to the texture.

Definition at line 398 of file GrResourceProvider.cpp.

                                                                                             {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
    return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership, cacheable);
}

wrapVulkanSecondaryCBAsRenderTarget()

sk_sp< GrRenderTarget > GrResourceProvider::wrapVulkanSecondaryCBAsRenderTarget	(	const SkImageInfo &	imageInfo,
		const GrVkDrawableInfo &	vkInfo
	)

Definition at line 415 of file GrResourceProvider.cpp.

                                                                      {
    ASSERT_SINGLE_OWNER
    return this->isAbandoned() ? nullptr : fGpu->wrapVulkanSecondaryCBAsRenderTarget(imageInfo,
                                                                                     vkInfo);
 
}

Friends And Related Function Documentation

GrResourceProviderPriv

friend class GrResourceProviderPriv

friend

Definition at line 421 of file GrResourceProvider.h.

---

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

• third_party/skia/src/gpu/ganesh/GrResourceProvider.h
• third_party/skia/src/gpu/ganesh/GrResourceProvider.cpp
• third_party/skia/src/gpu/ganesh/GrResourceProviderPriv.h