#include <GrDirectContext.h>

Inheritance diagram for GrDirectContext:

Classes
class	DirectContextID

Public Member Functions
	~GrDirectContext () override

void	resetContext (uint32_t state=kAll_GrBackendState)

void	resetGLTextureBindings ()

void	abandonContext () override

bool	abandoned () override

bool	isDeviceLost ()

sk_sp< GrContextThreadSafeProxy >	threadSafeProxy ()

bool	oomed ()

void	releaseResourcesAndAbandonContext ()

void	getResourceCacheLimits (int maxResources, size_t maxResourceBytes) const

size_t	getResourceCacheLimit () const

void	getResourceCacheUsage (int resourceCount, size_t resourceBytes) const

size_t	getResourceCachePurgeableBytes () const

void	setResourceCacheLimits (int maxResources, size_t maxResourceBytes)

void	setResourceCacheLimit (size_t maxResourceBytes)

void	freeGpuResources ()

void	performDeferredCleanup (std::chrono::milliseconds msNotUsed, GrPurgeResourceOptions opts=GrPurgeResourceOptions::kAllResources)

void	purgeResourcesNotUsedInMs (std::chrono::milliseconds msNotUsed)

void	purgeUnlockedResources (size_t bytesToPurge, bool preferScratchResources)

void	purgeUnlockedResources (GrPurgeResourceOptions opts)

bool	wait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait=true)

void	flushAndSubmit (GrSyncCpu sync=GrSyncCpu::kNo)

GrSemaphoresSubmitted	flush (const GrFlushInfo &info)

void	flush ()

GrSemaphoresSubmitted	flush (const sk_sp< const SkImage > &image, const GrFlushInfo &info)

void	flush (const sk_sp< const SkImage > &image)

void	flushAndSubmit (const sk_sp< const SkImage > &image)

GrSemaphoresSubmitted	flush (SkSurface *surface, SkSurfaces::BackendSurfaceAccess access, const GrFlushInfo &info)

GrSemaphoresSubmitted	flush (SkSurface surface, const GrFlushInfo &info, const skgpu::MutableTextureState newState=nullptr)

void	flushAndSubmit (SkSurface *surface, GrSyncCpu sync=GrSyncCpu::kNo)

void	flush (SkSurface *surface)

bool	submit (GrSyncCpu sync=GrSyncCpu::kNo)

void	checkAsyncWorkCompletion ()

void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const

bool	supportsDistanceFieldText () const

void	storeVkPipelineCacheData ()

GrBackendTexture	createBackendTexture (int width, int height, const GrBackendFormat &, skgpu::Mipmapped, GrRenderable, GrProtected=GrProtected::kNo, std::string_view label={})

GrBackendTexture	createBackendTexture (int width, int height, SkColorType, skgpu::Mipmapped, GrRenderable, GrProtected=GrProtected::kNo, std::string_view label={})

GrBackendTexture	createBackendTexture (int width, int height, const GrBackendFormat &, const SkColor4f &color, skgpu::Mipmapped, GrRenderable, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

GrBackendTexture	createBackendTexture (int width, int height, SkColorType, const SkColor4f &color, skgpu::Mipmapped, GrRenderable, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

GrBackendTexture	createBackendTexture (const SkPixmap srcData[], int numLevels, GrSurfaceOrigin, GrRenderable, GrProtected, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

GrBackendTexture	createBackendTexture (const SkPixmap &srcData, GrSurfaceOrigin textureOrigin, GrRenderable renderable, GrProtected isProtected, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

GrBackendTexture	createBackendTexture (const SkPixmap srcData[], int numLevels, GrRenderable renderable, GrProtected isProtected, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

GrBackendTexture	createBackendTexture (const SkPixmap &srcData, GrRenderable renderable, GrProtected isProtected, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr, std::string_view label={})

bool	updateBackendTexture (const GrBackendTexture &, const SkColor4f &color, GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)

bool	updateBackendTexture (const GrBackendTexture &, SkColorType skColorType, const SkColor4f &color, GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)

bool	updateBackendTexture (const GrBackendTexture &, const SkPixmap srcData[], int numLevels, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

bool	updateBackendTexture (const GrBackendTexture &texture, const SkPixmap &srcData, GrSurfaceOrigin textureOrigin=kTopLeft_GrSurfaceOrigin, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

bool	updateBackendTexture (const GrBackendTexture &texture, const SkPixmap srcData[], int numLevels, GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)

GrBackendTexture	createCompressedBackendTexture (int width, int height, const GrBackendFormat &, const SkColor4f &color, skgpu::Mipmapped, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

GrBackendTexture	createCompressedBackendTexture (int width, int height, SkTextureCompressionType, const SkColor4f &color, skgpu::Mipmapped, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

GrBackendTexture	createCompressedBackendTexture (int width, int height, const GrBackendFormat &, const void *data, size_t dataSize, skgpu::Mipmapped, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

GrBackendTexture	createCompressedBackendTexture (int width, int height, SkTextureCompressionType, const void *data, size_t dataSize, skgpu::Mipmapped, GrProtected=GrProtected::kNo, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

bool	updateCompressedBackendTexture (const GrBackendTexture &, const SkColor4f &color, GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)

bool	updateCompressedBackendTexture (const GrBackendTexture &, const void *data, size_t dataSize, GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)

bool	setBackendTextureState (const GrBackendTexture &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState=nullptr, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

bool	setBackendRenderTargetState (const GrBackendRenderTarget &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState=nullptr, GrGpuFinishedProc finishedProc=nullptr, GrGpuFinishedContext finishedContext=nullptr)

void	deleteBackendTexture (const GrBackendTexture &)

bool	precompileShader (const SkData &key, const SkData &data)

DirectContextID	directContextID () const

GrDirectContextPriv	priv ()

const GrDirectContextPriv	priv () const

SK_API int	maxTextureSize () const

SK_API int	maxRenderTargetSize () const

SK_API bool	colorTypeSupportedAsImage (SkColorType) const

SK_API bool	supportsProtectedContent () const

SK_API bool	colorTypeSupportedAsSurface (SkColorType colorType) const

SK_API int	maxSurfaceSampleCountForColorType (SkColorType colorType) const

Public Member Functions inherited from GrRecordingContext
	~GrRecordingContext () override

bool	abandoned () override

SK_API bool	colorTypeSupportedAsSurface (SkColorType colorType) const

SK_API int	maxTextureSize () const

SK_API int	maxRenderTargetSize () const

SK_API bool	colorTypeSupportedAsImage (SkColorType) const

SK_API bool	supportsProtectedContent () const

SK_API int	maxSurfaceSampleCountForColorType (SkColorType colorType) const

SK_API sk_sp< const SkCapabilities >	skCapabilities () const

GrRecordingContextPriv	priv ()

const GrRecordingContextPriv	priv () const

Public Member Functions inherited from GrImageContext
	~GrImageContext () override

GrImageContextPriv	priv ()

const GrImageContextPriv	priv () const

Public Member Functions inherited from GrContext_Base
	~GrContext_Base () override

virtual GrDirectContext *	asDirectContext ()

SK_API GrBackendApi	backend () const

SK_API GrBackendFormat	defaultBackendFormat (SkColorType, GrRenderable) const

SK_API GrBackendFormat	compressedBackendFormat (SkTextureCompressionType) const

SK_API int	maxSurfaceSampleCountForColorType (SkColorType colorType) const

sk_sp< GrContextThreadSafeProxy >	threadSafeProxy ()

GrBaseContextPriv	priv ()

const GrBaseContextPriv	priv () const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< GrDirectContext >	MakeMock (const GrMockOptions *, const GrContextOptions &)

static sk_sp< GrDirectContext >	MakeMock (const GrMockOptions *)

Protected Member Functions
	GrDirectContext (GrBackendApi backend, const GrContextOptions &options, sk_sp< GrContextThreadSafeProxy > proxy)

bool	init () override

GrAtlasManager *	onGetAtlasManager ()

skgpu::ganesh::SmallPathAtlasMgr *	onGetSmallPathAtlasMgr ()

GrDirectContext *	asDirectContext () override

Protected Member Functions inherited from GrRecordingContext
	GrRecordingContext (sk_sp< GrContextThreadSafeProxy >, bool ddlRecording)

bool	init () override

void	abandonContext () override

GrDrawingManager *	drawingManager ()

void	destroyDrawingManager ()

Arenas	arenas ()

OwnedArenas &&	detachArenas ()

GrProxyProvider *	proxyProvider ()

const GrProxyProvider *	proxyProvider () const

virtual void	recordProgramInfo (const GrProgramInfo *)

virtual void	detachProgramData (skia_private::TArray< ProgramData > *)

sktext::gpu::TextBlobRedrawCoordinator *	getTextBlobRedrawCoordinator ()

const sktext::gpu::TextBlobRedrawCoordinator *	getTextBlobRedrawCoordinator () const

GrThreadSafeCache *	threadSafeCache ()

const GrThreadSafeCache *	threadSafeCache () const

void	addOnFlushCallbackObject (GrOnFlushCallbackObject *)

GrRecordingContext *	asRecordingContext () override

Stats *	stats ()

const Stats *	stats () const

void	dumpJSON (SkJSONWriter *) const

Protected Member Functions inherited from GrImageContext
	GrImageContext (sk_sp< GrContextThreadSafeProxy >)

virtual SK_API void	abandonContext ()

virtual SK_API bool	abandoned ()

skgpu::SingleOwner *	singleOwner () const

GrImageContext *	asImageContext () override

Protected Member Functions inherited from GrContext_Base
	GrContext_Base (sk_sp< GrContextThreadSafeProxy >)

virtual bool	init ()

uint32_t	contextID () const

bool	matches (GrContext_Base *candidate) const

const GrContextOptions &	options () const

const GrCaps *	caps () const

sk_sp< const GrCaps >	refCaps () const

virtual GrImageContext *	asImageContext ()

virtual GrRecordingContext *	asRecordingContext ()

Friends
class	GrDirectContextPriv

Additional Inherited Members
Protected Attributes inherited from GrRecordingContext
class GrRecordingContext::Stats	fStats

std::unique_ptr< GrAuditTrail >	fAuditTrail

Protected Attributes inherited from GrContext_Base
sk_sp< GrContextThreadSafeProxy >	fThreadSafeProxy

Detailed Description

Definition at line 60 of file GrDirectContext.h.

Constructor & Destructor Documentation

◆ ~GrDirectContext()

GrDirectContext::~GrDirectContext ( )

override

Definition at line 96 of file GrDirectContext.cpp.

                                  {
    ASSERT_SINGLE_OWNER
    // this if-test protects against the case where the context is being destroyed
    // before having been fully created
    if (fGpu) {
        this->flushAndSubmit();
    }
 
    // We need to make sure all work is finished on the gpu before we start releasing resources.
    this->syncAllOutstandingGpuWork(/*shouldExecuteWhileAbandoned=*/false);
 
    this->destroyDrawingManager();
 
    // Ideally we could just let the ptr drop, but resource cache queries this ptr in releaseAll.
    if (fResourceCache) {
        fResourceCache->releaseAll();
    }
    // This has to be after GrResourceCache::releaseAll so that other threads that are holding
    // async pixel result don't try to destroy buffers off thread.
    fMappedBufferManager.reset();
}

◆ GrDirectContext()

GrDirectContext::GrDirectContext	(	GrBackendApi	backend,
		const GrContextOptions &	options,
		sk_sp< GrContextThreadSafeProxy >	proxy
	)

protected

Definition at line 88 of file GrDirectContext.cpp.

        : GrRecordingContext(std::move(proxy), false)
        , fDeleteCallbackHelper(new DeleteCallbackHelper(options.fContextDeleteContext,
                                                         options.fContextDeleteProc))
        , fDirectContextID(DirectContextID::Next()) {}

Member Function Documentation

◆ abandonContext()

void GrDirectContext::abandonContext ( )

overridevirtual

Abandons all GPU resources and assumes the underlying backend 3D API context is no longer usable. Call this if you have lost the associated GPU context, and thus internal texture, buffer, etc. references/IDs are now invalid. Calling this ensures that the destructors of the context and any of its created resource objects will not make backend 3D API calls. Content rendered but not previously flushed may be lost. After this function is called all subsequent calls on the context will fail or be no-ops.

The typical use case for this function is that the underlying 3D context was lost and further API calls may crash.

This call is not valid to be made inside ReleaseProcs passed into SkSurface or SkImages. The call will simply fail (and assert in debug) if it is called while inside a ReleaseProc.

For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to create the context must be kept alive even after abandoning the context. Those objects must live for the lifetime of the context object itself. The reason for this is so that we can continue to delete any outstanding GrBackendTextures/RenderTargets which must be cleaned up even in a device lost state.

Reimplemented from GrImageContext.

Definition at line 134 of file GrDirectContext.cpp.

                                     {
    if (GrRecordingContext::abandoned()) {
        return;
    }
 
    if (fInsideReleaseProcCnt) {
        SkDEBUGFAIL("Calling GrDirectContext::abandonContext() while inside a ReleaseProc is not "
                    "allowed");
        return;
    }
 
    GrRecordingContext::abandonContext();
 
    // We need to make sure all work is finished on the gpu before we start releasing resources.
    this->syncAllOutstandingGpuWork(this->caps()->mustSyncGpuDuringAbandon());
 
    fStrikeCache->freeAll();
 
    fMappedBufferManager->abandon();
 
    fResourceProvider->abandon();
 
    // abandon first so destructors don't try to free the resources in the API.
    fResourceCache->abandonAll();
 
    fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
 
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
    if (fSmallPathAtlasMgr) {
        fSmallPathAtlasMgr->reset();
    }
#endif
    fAtlasManager->freeAll();
}

◆ abandoned()

bool GrDirectContext::abandoned ( )

overridevirtual

Returns true if the context was abandoned or if the backend specific context has gotten into an unrecoverarble, lost state (e.g. in Vulkan backend if we've gotten a VK_ERROR_DEVICE_LOST). If the backend context is lost, this call will also abandon this context.

Reimplemented from GrImageContext.

Definition at line 169 of file GrDirectContext.cpp.

                                {
    if (GrRecordingContext::abandoned()) {
        return true;
    }
 
    if (fGpu && fGpu->isDeviceLost()) {
        this->abandonContext();
        return true;
    }
    return false;
}

◆ asDirectContext()

GrDirectContext * GrDirectContext::asDirectContext ( )

inlineoverrideprotectedvirtual

Reimplemented from GrContext_Base.

Definition at line 921 of file GrDirectContext.h.

921{ return this; }

◆ checkAsyncWorkCompletion()

void GrDirectContext::checkAsyncWorkCompletion ( )

Checks whether any asynchronous work is complete and if so calls related callbacks.

Definition at line 531 of file GrDirectContext.cpp.

                                               {
    if (fGpu) {
        fGpu->checkFinishProcs();
    }
}

◆ colorTypeSupportedAsImage()

bool GrRecordingContext::colorTypeSupportedAsImage ( SkColorType colorType ) const

Can a SkImage be created with the given color type.

Definition at line 84 of file GrRecordingContext.cpp.

                                                                              {
    GrBackendFormat format =
            this->caps()->getDefaultBackendFormat(SkColorTypeToGrColorType(colorType),
                                                  GrRenderable::kNo);
    return format.isValid();
}

◆ colorTypeSupportedAsSurface()

SK_API bool GrRecordingContext::colorTypeSupportedAsSurface ( SkColorType colorType ) const

inline

Can a SkSurface be created with the given color type. To check whether MSAA is supported use maxSurfaceSampleCountForColorType().

Definition at line 58 of file GrRecordingContext.h.

                                                                         {
        if (kR16G16_unorm_SkColorType == colorType ||
            kA16_unorm_SkColorType == colorType ||
            kA16_float_SkColorType == colorType ||
            kR16G16_float_SkColorType == colorType ||
            kR16G16B16A16_unorm_SkColorType == colorType ||
            kGray_8_SkColorType == colorType) {
            return false;
        }
 
        return this->maxSurfaceSampleCountForColorType(colorType) > 0;
    }

◆ createBackendTexture() [1/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	const SkPixmap &	srcData,
		GrRenderable	renderable,
		GrProtected	isProtected,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

Definition at line 594 of file GrDirectContext.cpp.

                                                                             {
    return this->createBackendTexture(&srcData,
                                      1,
                                      renderable,
                                      isProtected,
                                      finishedProc,
                                      finishedContext,
                                      label);
}

◆ createBackendTexture() [2/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	const SkPixmap &	srcData,
		GrSurfaceOrigin	textureOrigin,
		GrRenderable	renderable,
		GrProtected	isProtected,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

Convenience version createBackendTexture() that takes just a base level pixmap.

Definition at line 583 of file GrDirectContext.cpp.

                                                                             {
     return this->createBackendTexture(&srcData, 1, textureOrigin, renderable, isProtected,
                                       finishedProc, finishedContext, label);
}

◆ createBackendTexture() [3/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	const SkPixmap	srcData[],
		int	numLevels,
		GrRenderable	renderable,
		GrProtected	isProtected,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

Definition at line 609 of file GrDirectContext.cpp.

                                                                             {
    return this->createBackendTexture(srcData,
                                      numLevels,
                                      kTopLeft_GrSurfaceOrigin,
                                      renderable,
                                      isProtected,
                                      finishedProc,
                                      finishedContext,
                                      label);
}

◆ createBackendTexture() [4/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	const SkPixmap	srcData[],
		int	numLevels,
		GrSurfaceOrigin	textureOrigin,
		GrRenderable	renderable,
		GrProtected	isProtected,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

If possible, create a backend texture initialized with the provided pixmap data. The client should ensure that the returned backend texture is valid. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. If successful, the created backend texture will be compatible with the provided pixmap(s). Compatible, in this case, means that the backend format will be the result of calling defaultBackendFormat on the base pixmap's colortype. The src data can be deleted when this call returns. If numLevels is 1 a non-mipmapped texture will result. If a mipmapped texture is desired the data for all the mipmap levels must be provided. In the mipmapped case all the colortypes of the provided pixmaps must be the same. Additionally, all the miplevels must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). The GrSurfaceOrigin controls whether the pixmap data is vertically flipped in the texture. Note: the pixmap's alphatypes and colorspaces are ignored. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 773 of file GrDirectContext.cpp.

                                                                             {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return {};
    }
 
    if (!srcData || numProvidedLevels <= 0) {
        return {};
    }
 
    SkColorType colorType = srcData[0].colorType();
 
    skgpu::Mipmapped mipmapped = skgpu::Mipmapped::kNo;
    if (numProvidedLevels > 1) {
        mipmapped = skgpu::Mipmapped::kYes;
    }
 
    GrBackendFormat backendFormat = this->defaultBackendFormat(colorType, renderable);
    GrBackendTexture beTex = this->createBackendTexture(srcData[0].width(),
                                                        srcData[0].height(),
                                                        backendFormat,
                                                        mipmapped,
                                                        renderable,
                                                        isProtected,
                                                        label);
    if (!beTex.isValid()) {
        return {};
    }
    if (!update_texture_with_pixmaps(this,
                                     srcData,
                                     numProvidedLevels,
                                     beTex,
                                     textureOrigin,
                                     std::move(finishedCallback))) {
        this->deleteBackendTexture(beTex);
        return {};
    }
    return beTex;
}

◆ createBackendTexture() [5/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	int	width,
		int	height,
		const GrBackendFormat &	backendFormat,
		const SkColor4f &	color,
		skgpu::Mipmapped	mipmapped,
		GrRenderable	renderable,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

If possible, create a backend texture initialized to a particular color. The client should ensure that the returned backend texture is valid. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 710 of file GrDirectContext.cpp.

                                                                             {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    if (this->abandoned()) {
        return {};
    }
 
    return create_and_clear_backend_texture(this,
                                            {width, height},
                                            backendFormat,
                                            mipmapped,
                                            renderable,
                                            isProtected,
                                            std::move(finishedCallback),
                                            color.array(),
                                            label);
}

◆ createBackendTexture() [6/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	int	width,
		int	height,
		const GrBackendFormat &	backendFormat,
		skgpu::Mipmapped	mipmapped,
		GrRenderable	renderable,
		GrProtected	isProtected = `GrProtected::kNo`,
		std::string_view	label = `{}`
	)

The explicitly allocated backend texture API allows clients to use Skia to create backend objects outside of Skia proper (i.e., Skia's caching system will not know about them.)

It is the client's responsibility to delete all these objects (using deleteBackendTexture) before deleting the context used to create them. If the backend is Vulkan, the textures must be deleted before abandoning the context as well. Additionally, clients should only delete these objects on the thread for which that context is active.

The client is responsible for ensuring synchronization between different uses of the backend object (i.e., wrapping it in a surface, rendering to it, deleting the surface, rewrapping it in a image and drawing the image will require explicit synchronization on the client's part). If possible, create an uninitialized backend texture. The client should ensure that the returned backend texture is valid. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_UNDEFINED.

Definition at line 567 of file GrDirectContext.cpp.

                                                                             {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    if (this->abandoned()) {
        return GrBackendTexture();
    }
 
    return fGpu->createBackendTexture({width, height}, backendFormat, renderable,
                                      mipmapped, isProtected, label);
}

◆ createBackendTexture() [7/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	int	width,
		int	height,
		SkColorType	skColorType,
		const SkColor4f &	color,
		skgpu::Mipmapped	mipmapped,
		GrRenderable	renderable,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`,
		std::string_view	label = `{}`
	)

If possible, create a backend texture initialized to a particular color. The client should ensure that the returned backend texture is valid. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. If successful, the created backend texture will be compatible with the provided SkColorType. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 738 of file GrDirectContext.cpp.

                                                                             {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return {};
    }
 
    GrBackendFormat format = this->defaultBackendFormat(skColorType, renderable);
    if (!format.isValid()) {
        return {};
    }
 
    GrColorType grColorType = SkColorTypeToGrColorType(skColorType);
    SkColor4f swizzledColor = this->caps()->getWriteSwizzle(format, grColorType).applyTo(color);
 
    return create_and_clear_backend_texture(this,
                                            {width, height},
                                            format,
                                            mipmapped,
                                            renderable,
                                            isProtected,
                                            std::move(finishedCallback),
                                            swizzledColor.array(),
                                            label);
}

◆ createBackendTexture() [8/8]

GrBackendTexture GrDirectContext::createBackendTexture	(	int	width,
		int	height,
		SkColorType	skColorType,
		skgpu::Mipmapped	mipmapped,
		GrRenderable	renderable,
		GrProtected	isProtected = `GrProtected::kNo`,
		std::string_view	label = `{}`
	)

If possible, create an uninitialized backend texture. The client should ensure that the returned backend texture is valid. If successful, the created backend texture will be compatible with the provided SkColorType. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_UNDEFINED.

Definition at line 626 of file GrDirectContext.cpp.

                                                                             {
    if (this->abandoned()) {
        return GrBackendTexture();
    }
 
    const GrBackendFormat format = this->defaultBackendFormat(skColorType, renderable);
 
    return this->createBackendTexture(
            width, height, format, mipmapped, renderable, isProtected, label);
}

◆ createCompressedBackendTexture() [1/4]

GrBackendTexture GrDirectContext::createCompressedBackendTexture	(	int	width,
		int	height,
		const GrBackendFormat &	backendFormat,
		const SkColor4f &	color,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

If possible, create a compressed backend texture initialized to a particular color. The client should ensure that the returned backend texture is valid. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 935 of file GrDirectContext.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return {};
    }
 
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(backendFormat);
    if (compression == SkTextureCompressionType::kNone) {
        return {};
    }
 
    size_t size = SkCompressedDataSize(
            compression, {width, height}, nullptr, mipmapped == skgpu::Mipmapped::kYes);
    auto storage = std::make_unique<char[]>(size);
    skgpu::FillInCompressedData(compression, {width, height}, mipmapped, storage.get(), color);
    return create_and_update_compressed_backend_texture(this,
                                                        {width, height},
                                                        backendFormat,
                                                        mipmapped,
                                                        isProtected,
                                                        std::move(finishedCallback),
                                                        storage.get(),
                                                        size);
}

◆ createCompressedBackendTexture() [2/4]

GrBackendTexture GrDirectContext::createCompressedBackendTexture	(	int	width,
		int	height,
		const GrBackendFormat &	backendFormat,
		const void *	data,
		size_t	dataSize,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

If possible, create a backend texture initialized with the provided raw data. The client should ensure that the returned backend texture is valid. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture If numLevels is 1 a non-mipmapped texture will result. If a mipmapped texture is desired the data for all the mipmap levels must be provided. Additionally, all the miplevels must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). For the Vulkan backend the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 986 of file GrDirectContext.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return {};
    }
 
    return create_and_update_compressed_backend_texture(this,
                                                        {width, height},
                                                        backendFormat,
                                                        mipmapped,
                                                        isProtected,
                                                        std::move(finishedCallback),
                                                        compressedData,
                                                        dataSize);
}

◆ createCompressedBackendTexture() [3/4]

GrBackendTexture GrDirectContext::createCompressedBackendTexture	(	int	width,
		int	height,
		SkTextureCompressionType	compression,
		const SkColor4f &	color,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

Definition at line 970 of file GrDirectContext.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    GrBackendFormat format = this->compressedBackendFormat(compression);
    return this->createCompressedBackendTexture(width, height, format, color,
                                                mipmapped, isProtected, finishedProc,
                                                finishedContext);
}

◆ createCompressedBackendTexture() [4/4]

GrBackendTexture GrDirectContext::createCompressedBackendTexture	(	int	width,
		int	height,
		SkTextureCompressionType	compression,
		const void *	data,
		size_t	dataSize,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected = `GrProtected::kNo`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

Definition at line 1013 of file GrDirectContext.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    GrBackendFormat format = this->compressedBackendFormat(compression);
    return this->createCompressedBackendTexture(width, height, format, data, dataSize, mipmapped,
                                                isProtected, finishedProc, finishedContext);
}

◆ deleteBackendTexture()

void GrDirectContext::deleteBackendTexture ( const GrBackendTexture & backendTex )

Definition at line 1113 of file GrDirectContext.cpp.

                                                                             {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    // For the Vulkan backend we still must destroy the backend texture when the context is
    // abandoned.
    if ((this->abandoned() && this->backend() != GrBackendApi::kVulkan) || !backendTex.isValid()) {
        return;
    }
 
    fGpu->deleteBackendTexture(backendTex);
}

◆ directContextID()

DirectContextID GrDirectContext::directContextID ( ) const

inline

Definition at line 903 of file GrDirectContext.h.

903{ return fDirectContextID; }

◆ dumpMemoryStatistics()

void GrDirectContext::dumpMemoryStatistics ( SkTraceMemoryDump * traceMemoryDump ) const

Enumerates all cached GPU resources and dumps their memory to traceMemoryDump.

Definition at line 560 of file GrDirectContext.cpp.

                                                                                   {
    ASSERT_SINGLE_OWNER
    fResourceCache->dumpMemoryStatistics(traceMemoryDump);
    traceMemoryDump->dumpNumericValue("skia/gr_text_blob_cache", "size", "bytes",
                                      this->getTextBlobRedrawCoordinator()->usedBytes());
}

◆ flush() [1/7]

void GrDirectContext::flush ( )

inline

Definition at line 363 of file GrDirectContext.h.

363{ this->flush(GrFlushInfo()); }

GrDirectContext::flush

void flush()

Definition: GrDirectContext.h:363

GrFlushInfo

Definition: GrTypes.h:216

◆ flush() [2/7]

GrSemaphoresSubmitted GrDirectContext::flush ( const GrFlushInfo & info )

Call to ensure all drawing to the context has been flushed to underlying 3D API specific objects. A call to submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but glFlush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.

Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command buffer or encoder objects. However, these objects are not sent to the gpu until a submission occurs.

If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, and must keep them alive until then. If this call returns GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardless of semaphore submission the context will still be flushed. It should be emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.

Definition at line 432 of file GrDirectContext.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
    if (this->abandoned()) {
        if (info.fFinishedProc) {
            info.fFinishedProc(info.fFinishedContext);
        }
        if (info.fSubmittedProc) {
            info.fSubmittedProc(info.fSubmittedContext, false);
        }
        return GrSemaphoresSubmitted::kNo;
    }
 
    return this->drawingManager()->flushSurfaces(
            {}, SkSurfaces::BackendSurfaceAccess::kNoAccess, info, nullptr);
}

◆ flush() [3/7]

void GrDirectContext::flush ( const sk_sp< const SkImage > & image )

Definition at line 474 of file GrDirectContext.cpp.

                                                             {
    this->flush(image, {});
}

◆ flush() [4/7]

GrSemaphoresSubmitted GrDirectContext::flush	(	const sk_sp< const SkImage > &	image,
		const GrFlushInfo &	info
	)

Flushes any pending uses of texture-backed images in the GPU backend. If the image is not texture-backed (including promise texture images) or if the GrDirectContext does not have the same context ID as the context backing the image then this is a no-op. If the image was not used in any non-culled draws in the current queue of work for the passed GrDirectContext then this is a no-op unless the GrFlushInfo contains semaphores or a finish proc. Those are respected even when the image has not been used.

Parameters

image	the non-null image to flush.
info	flush options

Definition at line 461 of file GrDirectContext.cpp.

                                                                           {
    if (!image) {
        return GrSemaphoresSubmitted::kNo;
    }
    auto ib = as_IB(image);
    if (!ib->isGaneshBacked()) {
        return GrSemaphoresSubmitted::kNo;
    }
    auto igb = static_cast<const SkImage_GaneshBase*>(image.get());
    return igb->flush(this, flushInfo);
}

◆ flush() [5/7]

void GrDirectContext::flush ( SkSurface * surface )

Flushes the given surface with the default GrFlushInfo.

Has no effect on a CPU-backed surface.

Definition at line 525 of file GrDirectContext.cpp.

                                              {
    this->flush(surface, GrFlushInfo(), nullptr);
}

◆ flush() [6/7]

GrSemaphoresSubmitted GrDirectContext::flush	(	SkSurface *	surface,
		const GrFlushInfo &	info,
		const skgpu::MutableTextureState *	newState = `nullptr`
	)

Same as above except:

If a skgpu::MutableTextureState is passed in, at the end of the flush we will transition the surface to be in the state requested by the skgpu::MutableTextureState. If the surface (or SkImage or GrBackendSurface wrapping the same backend object) is used again after this flush the state may be changed and no longer match what is requested here. This is often used if the surface will be used for presenting or external use and the client wants backend object to be prepped for that use. A finishedProc or semaphore on the GrFlushInfo will also include the work for any requested state change.

If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to tell Skia to not change those respective states.

Parameters

surface	The GPU backed surface to be flushed. Has no effect on a CPU-backed surface.
info	flush options
newState	optional state change request after flush

Definition at line 501 of file GrDirectContext.cpp.

                                                                                       {
    if (!surface) {
        return GrSemaphoresSubmitted::kNo;
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return GrSemaphoresSubmitted::kNo;
    }
 
    auto gs = static_cast<SkSurface_Ganesh*>(surface);
    SkASSERT(this->priv().matches(gs->getDevice()->recordingContext()->asDirectContext()));
    GrRenderTargetProxy* rtp = gs->getDevice()->targetProxy();
 
    return this->priv().flushSurface(
            rtp, SkSurfaces::BackendSurfaceAccess::kNoAccess, info, newState);
}

◆ flush() [7/7]

GrSemaphoresSubmitted GrDirectContext::flush	(	SkSurface *	surface,
		SkSurfaces::BackendSurfaceAccess	access,
		const GrFlushInfo &	info
	)

Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA. A call to GrDirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but glFlush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.

Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command buffer or encoder objects. However, these objects are not sent to the gpu until a submission occurs.

The work that is submitted to the GPU will be dependent on the BackendSurfaceAccess that is passed in.

If BackendSurfaceAccess::kNoAccess is passed in all commands will be issued to the GPU.

If BackendSurfaceAccess::kPresent is passed in and the backend API is not Vulkan, it is treated the same as kNoAccess. If the backend API is Vulkan, the VkImage that backs the SkSurface will be transferred back to its original queue. If the SkSurface was created by wrapping a VkImage, the queue will be set to the queue which was originally passed in on the GrVkImageInfo. Additionally, if the original queue was not external or foreign the layout of the VkImage will be set to VK_IMAGE_LAYOUT_PRESENT_SRC_KHR.

The GrFlushInfo describes additional options to flush. Please see documentation at GrFlushInfo for more info.

If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, but must keep them alive until then. If a submit flag was passed in with the flush these valid semaphores can we waited on immediately. If this call returns GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardless of semaphore submission the context will still be flushed. It should be emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.

Pending surface commands are flushed regardless of the return result.

Parameters

surface	The GPU backed surface to be flushed. Has no effect on a CPU-backed surface.
access	type of access the call will do on the backend object after flush
info	flush options

Definition at line 483 of file GrDirectContext.cpp.

                                                                      {
    if (!surface) {
        return GrSemaphoresSubmitted::kNo;
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return GrSemaphoresSubmitted::kNo;
    }
 
    auto gs = static_cast<SkSurface_Ganesh*>(surface);
    SkASSERT(this->priv().matches(gs->getDevice()->recordingContext()->asDirectContext()));
    GrRenderTargetProxy* rtp = gs->getDevice()->targetProxy();
 
    return this->priv().flushSurface(rtp, access, info, nullptr);
}

◆ flushAndSubmit() [1/3]

void GrDirectContext::flushAndSubmit ( const sk_sp< const SkImage > & image )

Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the GPU.

Definition at line 478 of file GrDirectContext.cpp.

                                                                      {
    this->flush(image, {});
    this->submit();
}

◆ flushAndSubmit() [2/3]

void GrDirectContext::flushAndSubmit ( GrSyncCpu sync = GrSyncCpu::kNo )

inline

Call to ensure all drawing to the context has been flushed and submitted to the underlying 3D API. This is equivalent to calling GrContext::flush with a default GrFlushInfo followed by GrContext::submit(sync).

Definition at line 332 of file GrDirectContext.h.

                                                       {
        this->flush(GrFlushInfo());
        this->submit(sync);
    }

◆ flushAndSubmit() [3/3]

void GrDirectContext::flushAndSubmit	(	SkSurface *	surface,
		GrSyncCpu	sync = `GrSyncCpu::kNo`
	)

Call to ensure all reads/writes of the surface have been issued to the underlying 3D API. Skia will correctly order its own draws and pixel operations. This must to be used to ensure correct ordering when the surface backing store is accessed outside Skia (e.g. direct use of the 3D API or a windowing system). This is equivalent to calling ::flush with a default GrFlushInfo followed by ::submit(syncCpu).

Has no effect on a CPU-backed surface.

Definition at line 520 of file GrDirectContext.cpp.

                                                                       {
    this->flush(surface, SkSurfaces::BackendSurfaceAccess::kNoAccess, GrFlushInfo());
    this->submit(sync);
}

◆ freeGpuResources()

void GrDirectContext::freeGpuResources ( )

Frees GPU created by the context. Can be called to reduce GPU memory pressure.

Definition at line 220 of file GrDirectContext.cpp.

                                       {
    ASSERT_SINGLE_OWNER
 
    if (this->abandoned()) {
        return;
    }
 
    this->flushAndSubmit();
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
    if (fSmallPathAtlasMgr) {
        fSmallPathAtlasMgr->reset();
    }
#endif
    fAtlasManager->freeAll();
 
    // TODO: the glyph cache doesn't hold any GpuResources so this call should not be needed here.
    // Some slack in the GrTextBlob's implementation requires it though. That could be fixed.
    fStrikeCache->freeAll();
 
    this->drawingManager()->freeGpuResources();
 
    fResourceCache->purgeUnlockedResources(GrPurgeResourceOptions::kAllResources);
}

◆ getResourceCacheLimit()

size_t GrDirectContext::getResourceCacheLimit ( ) const

Return the current GPU resource cache limit in bytes.

Definition at line 330 of file GrDirectContext.cpp.

                                                    {
    ASSERT_SINGLE_OWNER
    return fResourceCache->getMaxResourceBytes();
}

◆ getResourceCacheLimits()

void GrDirectContext::getResourceCacheLimits	(	int *	maxResources,
		size_t *	maxResourceBytes
	)		const

DEPRECATED Return the current GPU resource cache limits.

Parameters

maxResources	If non-null, will be set to -1.
maxResourceBytes	If non-null, returns maximum number of bytes of video memory that can be held in the cache.

Definition at line 320 of file GrDirectContext.cpp.

                                                                                              {
    ASSERT_SINGLE_OWNER
    if (maxResources) {
        *maxResources = -1;
    }
    if (maxResourceBytes) {
        *maxResourceBytes = this->getResourceCacheLimit();
    }
}

◆ getResourceCachePurgeableBytes()

size_t GrDirectContext::getResourceCachePurgeableBytes ( ) const

Gets the number of bytes in the cache consumed by purgeable (e.g. unlocked) resources.

Definition at line 315 of file GrDirectContext.cpp.

                                                             {
    ASSERT_SINGLE_OWNER
    return fResourceCache->getPurgeableBytes();
}

◆ getResourceCacheUsage()

void GrDirectContext::getResourceCacheUsage	(	int *	resourceCount,
		size_t *	resourceBytes
	)		const

Gets the current GPU resource cache usage.

Parameters

resourceCount	If non-null, returns the number of resources that are held in the cache.
maxResourceBytes	If non-null, returns the total number of bytes of video memory held in the cache.

Definition at line 304 of file GrDirectContext.cpp.

                                                                                           {
    ASSERT_SINGLE_OWNER
 
    if (resourceCount) {
        *resourceCount = fResourceCache->getBudgetedResourceCount();
    }
    if (resourceBytes) {
        *resourceBytes = fResourceCache->getBudgetedResourceBytes();
    }
}

◆ init()

bool GrDirectContext::init ( )

overrideprotectedvirtual

Reimplemented from GrContext_Base.

Definition at line 244 of file GrDirectContext.cpp.

                           {
    ASSERT_SINGLE_OWNER
    if (!fGpu) {
        return false;
    }
 
    fThreadSafeProxy->priv().init(fGpu->refCaps(), fGpu->refPipelineBuilder());
    if (!GrRecordingContext::init()) {
        return false;
    }
 
    SkASSERT(this->getTextBlobRedrawCoordinator());
    SkASSERT(this->threadSafeCache());
 
    fStrikeCache = std::make_unique<StrikeCache>();
    fResourceCache = std::make_unique<GrResourceCache>(this->singleOwner(),
                                                       this->directContextID(),
                                                       this->contextID());
    fResourceCache->setProxyProvider(this->proxyProvider());
    fResourceCache->setThreadSafeCache(this->threadSafeCache());
#if defined(GR_TEST_UTILS)
    if (this->options().fResourceCacheLimitOverride != -1) {
        this->setResourceCacheLimit(this->options().fResourceCacheLimitOverride);
    }
#endif
    fResourceProvider = std::make_unique<GrResourceProvider>(fGpu.get(), fResourceCache.get(),
                                                             this->singleOwner());
    fMappedBufferManager = std::make_unique<GrClientMappedBufferManager>(this->directContextID());
 
    fDidTestPMConversions = false;
 
    // DDL TODO: we need to think through how the task group & persistent cache
    // get passed on to/shared between all the DDLRecorders created with this context.
    if (this->options().fExecutor) {
        fTaskGroup = std::make_unique<SkTaskGroup>(*this->options().fExecutor);
    }
 
    fPersistentCache = this->options().fPersistentCache;
 
    GrDrawOpAtlas::AllowMultitexturing allowMultitexturing;
    if (GrContextOptions::Enable::kNo == this->options().fAllowMultipleGlyphCacheTextures ||
        // multitexturing supported only if range can represent the index + texcoords fully
        !(this->caps()->shaderCaps()->fFloatIs32Bits ||
        this->caps()->shaderCaps()->fIntegerSupport)) {
        allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kNo;
    } else {
        allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kYes;
    }
 
    GrProxyProvider* proxyProvider = this->priv().proxyProvider();
 
    fAtlasManager = std::make_unique<GrAtlasManager>(proxyProvider,
                                                     this->options().fGlyphCacheTextureMaximumBytes,
                                                     allowMultitexturing,
                                                     this->options().fSupportBilerpFromGlyphAtlas);
    this->priv().addOnFlushCallbackObject(fAtlasManager.get());
 
    return true;
}

◆ isDeviceLost()

bool GrDirectContext::isDeviceLost ( )

Returns true if the backend specific context has gotten into an unrecoverarble, lost state (e.g. in Vulkan backend if we've gotten a VK_ERROR_DEVICE_LOST). If the backend context is lost, this call will also abandon this context.

Definition at line 181 of file GrDirectContext.cpp.

                                   {
    if (fGpu && fGpu->isDeviceLost()) {
        if (!GrRecordingContext::abandoned()) {
            this->abandonContext();
        }
        return true;
    }
    return false;
}

◆ MakeMock() [1/2]

sk_sp< GrDirectContext > GrDirectContext::MakeMock ( const GrMockOptions * mockOptions )

static

Definition at line 1164 of file GrDirectContext.cpp.

                                                                                 {
    GrContextOptions defaultOptions;
    return MakeMock(mockOptions, defaultOptions);
}

◆ MakeMock() [2/2]

sk_sp< GrDirectContext > GrDirectContext::MakeMock	(	const GrMockOptions *	mockOptions,
		const GrContextOptions &	options
	)

static

Definition at line 1169 of file GrDirectContext.cpp.

                                                                                  {
    sk_sp<GrDirectContext> direct(
            new GrDirectContext(GrBackendApi::kMock,
                                options,
                                GrContextThreadSafeProxyPriv::Make(GrBackendApi::kMock, options)));
 
    direct->fGpu = GrMockGpu::Make(mockOptions, options, direct.get());
    if (!direct->init()) {
        return nullptr;
    }
 
    return direct;
}

◆ maxRenderTargetSize()

int GrRecordingContext::maxRenderTargetSize ( ) const

Gets the maximum supported render target size.

Definition at line 79 of file GrRecordingContext.cpp.

169{ return this->caps()->maxRenderTargetSize(); }

GrCaps::maxRenderTargetSize

int maxRenderTargetSize() const

Definition: GrCaps.h:223

◆ maxSurfaceSampleCountForColorType()

SK_API int GrRecordingContext::maxSurfaceSampleCountForColorType ( SkColorType colorType ) const

inline

Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA rendering is supported for the color type. 0 is returned if rendering to this color type is not supported at all.

Definition at line 96 of file GrRecordingContext.h.

                                                                              {
        return GrImageContext::maxSurfaceSampleCountForColorType(colorType);
    }

◆ maxTextureSize()

int GrRecordingContext::maxTextureSize ( ) const

Gets the maximum supported texture size.

Definition at line 74 of file GrRecordingContext.cpp.

167{ return this->caps()->maxTextureSize(); }

GrCaps::maxTextureSize

int maxTextureSize() const

Definition: GrCaps.h:229

◆ onGetAtlasManager()

GrAtlasManager * GrDirectContext::onGetAtlasManager ( )

inlineprotected

Definition at line 916 of file GrDirectContext.h.

916{ return fAtlasManager.get(); }

◆ onGetSmallPathAtlasMgr()

skgpu::ganesh::SmallPathAtlasMgr * GrDirectContext::onGetSmallPathAtlasMgr ( )

protected

Definition at line 415 of file GrDirectContext.cpp.

                                                                      {
    if (!fSmallPathAtlasMgr) {
        fSmallPathAtlasMgr = std::make_unique<skgpu::ganesh::SmallPathAtlasMgr>();
 
        this->priv().addOnFlushCallbackObject(fSmallPathAtlasMgr.get());
    }
 
    if (!fSmallPathAtlasMgr->initAtlas(this->proxyProvider(), this->caps())) {
        return nullptr;
    }
 
    return fSmallPathAtlasMgr.get();
}

◆ oomed()

bool GrDirectContext::oomed ( )

Checks if the underlying 3D API reported an out-of-memory error. If this returns true it is reset and will return false until another out-of-memory error is reported by the 3D API. If the context is abandoned then this will report false.

Currently this is implemented for:

OpenGL [ES] - Note that client calls to glGetError() may swallow GL_OUT_OF_MEMORY errors and therefore hide the error from Skia. Also, it is not advised to use this in combination with enabling GrContextOptions::fSkipGLErrorChecks. That option may prevent the context from ever checking the GL context for OOM.

Vulkan - Reports true if VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY has occurred.

Definition at line 191 of file GrDirectContext.cpp.

191{ return fGpu ? fGpu->checkAndResetOOMed() : false; }

◆ performDeferredCleanup()

void GrDirectContext::performDeferredCleanup	(	std::chrono::milliseconds	msNotUsed,
		GrPurgeResourceOptions	opts = `GrPurgeResourceOptions::kAllResources`
	)

Purge GPU resources that haven't been used in the past 'msNotUsed' milliseconds or are otherwise marked for deletion, regardless of whether the context is under budget.

Parameters

msNotUsed	Only unlocked resources not used in these last milliseconds will be cleaned up.
opts	Specify which resources should be cleaned up. If kScratchResourcesOnly then, all unlocked scratch resources older than 'msNotUsed' will be purged but the unlocked resources with persistent data will remain. If kAllResources

Definition at line 362 of file GrDirectContext.cpp.

                                                                          {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    ASSERT_SINGLE_OWNER
 
    if (this->abandoned()) {
        return;
    }
 
    this->checkAsyncWorkCompletion();
    fMappedBufferManager->process();
    auto purgeTime = skgpu::StdSteadyClock::now() - msNotUsed;
 
    fResourceCache->purgeAsNeeded();
    fResourceCache->purgeResourcesNotUsedSince(purgeTime, opts);
 
    // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
    // place to purge stale blobs
    this->getTextBlobRedrawCoordinator()->purgeStaleBlobs();
}

◆ precompileShader()

bool GrDirectContext::precompileShader	(	const SkData &	key,
		const SkData &	data
	)

Definition at line 1126 of file GrDirectContext.cpp.

                                                                            {
    return fGpu->precompileShader(key, data);
}

◆ priv() [1/2]

GrDirectContextPriv GrDirectContext::priv ( )

inline

Definition at line 186 of file GrDirectContextPriv.h.

186{ return GrDirectContextPriv(this); }

GrDirectContext::GrDirectContextPriv

friend class GrDirectContextPriv

Definition: GrDirectContext.h:989

◆ priv() [2/2]

const GrDirectContextPriv GrDirectContext::priv ( ) const

inline

Definition at line 189 of file GrDirectContextPriv.h.

                                                             {
    return GrDirectContextPriv(const_cast<GrDirectContext*>(this));
}

◆ purgeResourcesNotUsedInMs()

void GrDirectContext::purgeResourcesNotUsedInMs ( std::chrono::milliseconds msNotUsed )

inline

Definition at line 243 of file GrDirectContext.h.

                                                                    {
        this->performDeferredCleanup(msNotUsed);
    }

◆ purgeUnlockedResources() [1/2]

void GrDirectContext::purgeUnlockedResources ( GrPurgeResourceOptions opts )

This entry point is intended for instances where an app has been backgrounded or suspended. If 'scratchResourcesOnly' is true all unlocked scratch resources will be purged but the unlocked resources with persistent data will remain. If 'scratchResourcesOnly' is false then all unlocked resources will be purged. In either case, after the unlocked resources are purged a separate pass will be made to ensure that resource usage is under budget (i.e., even if 'scratchResourcesOnly' is true some resources with persistent data may be purged to be under budget).

Parameters

opts	If kScratchResourcesOnly only unlocked scratch resources will be purged prior enforcing the budget requirements.

Definition at line 345 of file GrDirectContext.cpp.

                                                                        {
    ASSERT_SINGLE_OWNER
 
    if (this->abandoned()) {
        return;
    }
 
    fResourceCache->purgeUnlockedResources(opts);
    fResourceCache->purgeAsNeeded();
 
    // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
    // place to purge stale blobs
    this->getTextBlobRedrawCoordinator()->purgeStaleBlobs();
 
    fGpu->releaseUnlockedBackendObjects();
}

◆ purgeUnlockedResources() [2/2]

void GrDirectContext::purgeUnlockedResources	(	size_t	bytesToPurge,
		bool	preferScratchResources
	)

Purge unlocked resources from the cache until the the provided byte count has been reached or we have purged all unlocked resources. The default policy is to purge in LRU order, but can be overridden to prefer purging scratch resources (in LRU order) prior to purging other resource types.

Parameters

maxBytesToPurge	the desired number of bytes to be purged.
preferScratchResources	If true scratch resources will be purged prior to other resource types.

Definition at line 384 of file GrDirectContext.cpp.

                                                                                             {
    ASSERT_SINGLE_OWNER
 
    if (this->abandoned()) {
        return;
    }
 
    fResourceCache->purgeUnlockedResources(bytesToPurge, preferScratchResources);
}

◆ releaseResourcesAndAbandonContext()

void GrDirectContext::releaseResourcesAndAbandonContext ( )

This is similar to abandonContext() however the underlying 3D context is not yet lost and the context will cleanup all allocated resources before returning. After returning it will assume that the underlying context may no longer be valid.

The typical use case for this function is that the client is going to destroy the 3D context but can't guarantee that context will be destroyed first (perhaps because it may be ref'ed elsewhere by either the client or Skia objects).

For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to create the context must be alive before calling releaseResourcesAndAbandonContext.

Definition at line 193 of file GrDirectContext.cpp.

                                                        {
    if (GrRecordingContext::abandoned()) {
        return;
    }
 
    GrRecordingContext::abandonContext();
 
    // We need to make sure all work is finished on the gpu before we start releasing resources.
    this->syncAllOutstandingGpuWork(/*shouldExecuteWhileAbandoned=*/true);
 
    fResourceProvider->abandon();
 
    // Release all resources in the backend 3D API.
    fResourceCache->releaseAll();
 
    // Must be after GrResourceCache::releaseAll().
    fMappedBufferManager.reset();
 
    fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
    if (fSmallPathAtlasMgr) {
        fSmallPathAtlasMgr->reset();
    }
#endif
    fAtlasManager->freeAll();
}

◆ resetContext()

void GrDirectContext::resetContext ( uint32_t state = kAll_GrBackendState )

The context normally assumes that no outsider is setting state within the underlying 3D API's context/device/whatever. This call informs the context that the state was modified and it should resend. Shouldn't be called frequently for good performance. The flag bits, state, is dependent on which backend is used by the context, either GL or D3D (possible in future).

Definition at line 129 of file GrDirectContext.cpp.

                                                 {
    ASSERT_SINGLE_OWNER
    fGpu->markContextDirty(state);
}

◆ resetGLTextureBindings()

void GrDirectContext::resetGLTextureBindings ( )

If the backend is GrBackendApi::kOpenGL, then all texture unit/target combinations for which the context has modified the bound texture will have texture id 0 bound. This does not flush the context. Calling resetContext() does not change the set that will be bound to texture id 0 on the next call to resetGLTextureBindings(). After this is called all unit/target combinations are considered to have unmodified bindings until the context subsequently modifies them (meaning if this is called twice in a row with no intervening context usage then the second call is a no-op.)

Definition at line 122 of file GrDirectContext.cpp.

                                             {
    if (this->abandoned() || this->backend() != GrBackendApi::kOpenGL) {
        return;
    }
    fGpu->resetTextureBindings();
}

◆ setBackendRenderTargetState()

bool GrDirectContext::setBackendRenderTargetState	(	const GrBackendRenderTarget &	backendRenderTarget,
		const skgpu::MutableTextureState &	state,
		skgpu::MutableTextureState *	previousState = `nullptr`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

Definition at line 1098 of file GrDirectContext.cpp.

                                                                                        {
    auto callback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    return fGpu->setBackendRenderTargetState(backendRenderTarget, state, previousState,
                                             std::move(callback));
}

◆ setBackendTextureState()

bool GrDirectContext::setBackendTextureState	(	const GrBackendTexture &	backendTexture,
		const skgpu::MutableTextureState &	state,
		skgpu::MutableTextureState *	previousState = `nullptr`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

Updates the state of the GrBackendTexture/RenderTarget to have the passed in skgpu::MutableTextureState. All objects that wrap the backend surface (i.e. SkSurfaces and SkImages) will also be aware of this state change. This call does not submit the state change to the gpu, but requires the client to call submit to send it to the GPU. The work for this call is ordered linearly with all other calls that require GrContext::submit to be called (e.g updateBackendTexture and flush). If finishedProc is not null then it will be called with finishedContext after the state transition is known to have occurred on the GPU.

See skgpu::MutableTextureState to see what state can be set via this call.

If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to tell Skia to not change those respective states.

If previousState is not null and this returns true, then Skia will have filled in previousState to have the values of the state before this call.

Definition at line 1083 of file GrDirectContext.cpp.

                                                                                   {
    auto callback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    return fGpu->setBackendTextureState(backendTexture, state, previousState, std::move(callback));
}

◆ setResourceCacheLimit()

void GrDirectContext::setResourceCacheLimit ( size_t maxResourceBytes )

Specify the GPU resource cache limit. If the cache currently exceeds this limit, it will be purged (LRU) to keep the cache within the limit.

Parameters

maxResourceBytes The maximum number of bytes of video memory that can be held in the cache.

Definition at line 340 of file GrDirectContext.cpp.

                                                                   {
    ASSERT_SINGLE_OWNER
    fResourceCache->setLimit(maxResourceBytes);
}

◆ setResourceCacheLimits()

void GrDirectContext::setResourceCacheLimits	(	int	maxResources,
		size_t	maxResourceBytes
	)

DEPRECATED Specify the GPU resource cache limits. If the current cache exceeds the maxResourceBytes limit, it will be purged (LRU) to keep the cache within the limit.

Parameters

maxResources	Unused.
maxResourceBytes	The maximum number of bytes of video memory that can be held in the cache.

Definition at line 335 of file GrDirectContext.cpp.

                                                                                {
    ASSERT_SINGLE_OWNER
    this->setResourceCacheLimit(maxResourceBytes);
}

◆ storeVkPipelineCacheData()

void GrDirectContext::storeVkPipelineCacheData ( )

Definition at line 546 of file GrDirectContext.cpp.

                                               {
    if (fGpu) {
        fGpu->storeVkPipelineCacheData();
    }
}

◆ submit()

bool GrDirectContext::submit ( GrSyncCpu sync = GrSyncCpu::kNo )

Submit outstanding work to the gpu from all previously un-submitted flushes. The return value of the submit will indicate whether or not the submission to the GPU was successful.

If the call returns true, all previously passed in semaphores in flush calls will have been submitted to the GPU and they can safely be waited on. The caller should wait on those semaphores or perform some other global synchronization before deleting the semaphores.

If it returns false, then those same semaphores will not have been submitted and we will not try to submit them again. The caller is free to delete the semaphores at any time.

If sync flag is GrSyncCpu::kYes, this function will return once the gpu has finished with all submitted work.

Definition at line 448 of file GrDirectContext.cpp.

                                           {
    ASSERT_SINGLE_OWNER
    if (this->abandoned()) {
        return false;
    }
 
    if (!fGpu) {
        return false;
    }
 
    return fGpu->submitToGpu(sync);
}

◆ supportsDistanceFieldText()

bool GrDirectContext::supportsDistanceFieldText ( ) const

Definition at line 554 of file GrDirectContext.cpp.

                                                      {
    return this->caps()->shaderCaps()->supportsDistanceFieldText();
}

◆ supportsProtectedContent()

bool GrRecordingContext::supportsProtectedContent ( ) const

Does this context support protected content?

Definition at line 89 of file GrRecordingContext.cpp.

                                                        {
    return this->caps()->supportsProtectedContent();
}

◆ threadSafeProxy()

sk_sp< GrContextThreadSafeProxy > GrDirectContext::threadSafeProxy ( )

Definition at line 118 of file GrDirectContext.cpp.

                                                                 {
    return GrRecordingContext::threadSafeProxy();
}

◆ updateBackendTexture() [1/5]

bool GrDirectContext::updateBackendTexture	(	const GrBackendTexture &	backendTexture,
		const SkColor4f &	color,
		GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

If possible, updates a backend texture to be filled to a particular color. The client should check the return value to see if the update was successful. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to update the GrBackendTexture. For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 836 of file GrDirectContext.cpp.

                                                                                 {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    return fGpu->clearBackendTexture(backendTexture, std::move(finishedCallback), color.array());
}

◆ updateBackendTexture() [2/5]

bool GrDirectContext::updateBackendTexture	(	const GrBackendTexture &	backendTexture,
		const SkPixmap	srcData[],
		int	numLevels,
		GrSurfaceOrigin	textureOrigin = `kTopLeft_GrSurfaceOrigin`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

If possible, updates a backend texture filled with the provided pixmap data. The client should check the return value to see if the update was successful. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. The backend texture must be compatible with the provided pixmap(s). Compatible, in this case, means that the backend format is compatible with the base pixmap's colortype. The src data can be deleted when this call returns. If the backend texture is mip mapped, the data for all the mipmap levels must be provided. In the mipmapped case all the colortypes of the provided pixmaps must be the same. Additionally, all the miplevels must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). The GrSurfaceOrigin controls whether the pixmap data is vertically flipped in the texture. Note: the pixmap's alphatypes and colorspaces are ignored. For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 875 of file GrDirectContext.cpp.

                                                                                 {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    if (!srcData || numLevels <= 0) {
        return false;
    }
 
    // If the texture has MIP levels then we require that the full set is overwritten.
    int numExpectedLevels = 1;
    if (backendTexture.hasMipmaps()) {
        numExpectedLevels = SkMipmap::ComputeLevelCount(backendTexture.width(),
                                                        backendTexture.height()) + 1;
    }
    if (numLevels != numExpectedLevels) {
        return false;
    }
    return update_texture_with_pixmaps(this,
                                       srcData,
                                       numLevels,
                                       backendTexture,
                                       textureOrigin,
                                       std::move(finishedCallback));
}

◆ updateBackendTexture() [3/5]

bool GrDirectContext::updateBackendTexture	(	const GrBackendTexture &	backendTexture,
		SkColorType	skColorType,
		const SkColor4f &	color,
		GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

If possible, updates a backend texture to be filled to a particular color. The data in GrBackendTexture and passed in color is interpreted with respect to the passed in SkColorType. The client should check the return value to see if the update was successful. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to update the GrBackendTexture. For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 849 of file GrDirectContext.cpp.

                                                                                 {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    GrBackendFormat format = backendTexture.getBackendFormat();
    GrColorType grColorType = SkColorTypeToGrColorType(skColorType);
 
    if (!this->caps()->areColorTypeAndFormatCompatible(grColorType, format)) {
        return false;
    }
 
    skgpu::Swizzle swizzle = this->caps()->getWriteSwizzle(format, grColorType);
    SkColor4f swizzledColor = swizzle.applyTo(color);
 
    return fGpu->clearBackendTexture(backendTexture,
                                     std::move(finishedCallback),
                                     swizzledColor.array());
}

◆ updateBackendTexture() [4/5]

bool GrDirectContext::updateBackendTexture	(	const GrBackendTexture &	texture,
		const SkPixmap &	srcData,
		GrSurfaceOrigin	textureOrigin = `kTopLeft_GrSurfaceOrigin`,
		GrGpuFinishedProc	finishedProc = `nullptr`,
		GrGpuFinishedContext	finishedContext = `nullptr`
	)

inline

Convenience version of updateBackendTexture that takes just a base level pixmap.

Definition at line 710 of file GrDirectContext.h.

                                                                              {
        return this->updateBackendTexture(texture,
                                          &srcData,
                                          1,
                                          textureOrigin,
                                          finishedProc,
                                          finishedContext);
    }

◆ updateBackendTexture() [5/5]

bool GrDirectContext::updateBackendTexture	(	const GrBackendTexture &	texture,
		const SkPixmap	srcData[],
		int	numLevels,
		GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

Definition at line 823 of file GrDirectContext.cpp.

                                                                                 {
    return this->updateBackendTexture(texture,
                                      srcData,
                                      numLevels,
                                      kTopLeft_GrSurfaceOrigin,
                                      finishedProc,
                                      finishedContext);
}

◆ updateCompressedBackendTexture() [1/2]

bool GrDirectContext::updateCompressedBackendTexture	(	const GrBackendTexture &	backendTexture,
		const SkColor4f &	color,
		GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

If possible, updates a backend texture filled with the provided color. If the texture is mipmapped, all levels of the mip chain will be updated to have the supplied color. The client should check the return value to see if the update was successful. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 1029 of file GrDirectContext.cpp.

                                                                                           {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    SkTextureCompressionType compression =
            GrBackendFormatToCompressionType(backendTexture.getBackendFormat());
    if (compression == SkTextureCompressionType::kNone) {
        return {};
    }
    size_t size = SkCompressedDataSize(compression,
                                       backendTexture.dimensions(),
                                       nullptr,
                                       backendTexture.hasMipmaps());
    SkAutoMalloc storage(size);
    skgpu::FillInCompressedData(compression,
                                backendTexture.dimensions(),
                                backendTexture.mipmapped(),
                                static_cast<char*>(storage.get()),
                                color);
    return fGpu->updateCompressedBackendTexture(backendTexture,
                                                std::move(finishedCallback),
                                                storage.get(),
                                                size);
}

◆ updateCompressedBackendTexture() [2/2]

bool GrDirectContext::updateCompressedBackendTexture	(	const GrBackendTexture &	backendTexture,
		const void *	data,
		size_t	dataSize,
		GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

If possible, updates a backend texture filled with the provided raw data. The client should check the return value to see if the update was successful. The client can pass in a finishedProc to be notified when the data has been uploaded by the gpu and the texture can be deleted. The client is required to call submit to send the upload work to the gpu. The finishedProc will always get called even if we failed to create the GrBackendTexture. If a mipmapped texture is passed in, the data for all the mipmap levels must be provided. Additionally, all the miplevels must be sized correctly (please see SkMipMap::ComputeLevelSize and ComputeLevelCount). For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 1060 of file GrDirectContext.cpp.

                                                                                           {
    auto finishedCallback = skgpu::RefCntedCallback::Make(finishedProc, finishedContext);
 
    if (this->abandoned()) {
        return false;
    }
 
    if (!compressedData) {
        return false;
    }
 
    return fGpu->updateCompressedBackendTexture(backendTexture,
                                                std::move(finishedCallback),
                                                compressedData,
                                                dataSize);
}

◆ wait()

bool GrDirectContext::wait	(	int	numSemaphores,
		const GrBackendSemaphore *	waitSemaphores,
		bool	deleteSemaphoresAfterWait = `true`
	)

Inserts a list of GPU semaphores that the current GPU-backed API must wait on before executing any more commands on the GPU. We only guarantee blocking transfer and fragment shader work, but may block earlier stages as well depending on the backend.If this call returns false, then the GPU back-end will not wait on any passed in semaphores, and the client will still own the semaphores, regardless of the value of deleteSemaphoresAfterWait.

If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case it is the client's responsibility to not destroy or attempt to reuse the semaphores until it knows that Skia has finished waiting on them. This can be done by using finishedProcs on flush calls.

This is not supported on the GL backend.

Definition at line 395 of file GrDirectContext.cpp.

                                                           {
    if (!fGpu || !fGpu->caps()->backendSemaphoreSupport()) {
        return false;
    }
    GrWrapOwnership ownership =
            deleteSemaphoresAfterWait ? kAdopt_GrWrapOwnership : kBorrow_GrWrapOwnership;
    for (int i = 0; i < numSemaphores; ++i) {
        std::unique_ptr<GrSemaphore> sema = fResourceProvider->wrapBackendSemaphore(
                waitSemaphores[i], GrSemaphoreWrapType::kWillWait, ownership);
        // If we failed to wrap the semaphore it means the client didn't give us a valid semaphore
        // to begin with. Therefore, it is fine to not wait on it.
        if (sema) {
            fGpu->waitSemaphore(sema.get());
        }
    }
    return true;
}

Friends And Related Function Documentation

◆ GrDirectContextPriv

friend class GrDirectContextPriv

friend

Definition at line 989 of file GrDirectContext.h.

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

third_party/skia/include/gpu/GrDirectContext.h
third_party/skia/src/gpu/ganesh/GrDirectContext.cpp
third_party/skia/src/gpu/ganesh/GrDirectContextPriv.h

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~GrDirectContext()

◆ GrDirectContext()

Member Function Documentation

◆ abandonContext()

◆ abandoned()

◆ asDirectContext()

◆ checkAsyncWorkCompletion()

◆ colorTypeSupportedAsImage()

◆ colorTypeSupportedAsSurface()

◆ createBackendTexture() [1/8]

◆ createBackendTexture() [2/8]

◆ createBackendTexture() [3/8]

◆ createBackendTexture() [4/8]

◆ createBackendTexture() [5/8]

◆ createBackendTexture() [6/8]

◆ createBackendTexture() [7/8]

◆ createBackendTexture() [8/8]

◆ createCompressedBackendTexture() [1/4]

◆ createCompressedBackendTexture() [2/4]

◆ createCompressedBackendTexture() [3/4]

◆ createCompressedBackendTexture() [4/4]

◆ deleteBackendTexture()

◆ directContextID()

◆ dumpMemoryStatistics()

◆ flush() [1/7]

◆ flush() [2/7]

◆ flush() [3/7]

◆ flush() [4/7]

◆ flush() [5/7]

◆ flush() [6/7]

◆ flush() [7/7]

◆ flushAndSubmit() [1/3]

◆ flushAndSubmit() [2/3]

◆ flushAndSubmit() [3/3]

◆ freeGpuResources()

◆ getResourceCacheLimit()

◆ getResourceCacheLimits()

◆ getResourceCachePurgeableBytes()

◆ getResourceCacheUsage()

◆ init()

◆ isDeviceLost()

◆ MakeMock() [1/2]

◆ MakeMock() [2/2]

◆ maxRenderTargetSize()

◆ maxSurfaceSampleCountForColorType()

◆ maxTextureSize()

◆ onGetAtlasManager()

◆ onGetSmallPathAtlasMgr()

◆ oomed()

◆ performDeferredCleanup()

◆ precompileShader()

◆ priv() [1/2]

◆ priv() [2/2]

◆ purgeResourcesNotUsedInMs()

◆ purgeUnlockedResources() [1/2]

◆ purgeUnlockedResources() [2/2]

◆ releaseResourcesAndAbandonContext()

◆ resetContext()

◆ resetGLTextureBindings()

◆ setBackendRenderTargetState()

◆ setBackendTextureState()

◆ setResourceCacheLimit()

◆ setResourceCacheLimits()

◆ storeVkPipelineCacheData()

◆ submit()

◆ supportsDistanceFieldText()

◆ supportsProtectedContent()

◆ threadSafeProxy()

◆ updateBackendTexture() [1/5]

◆ updateBackendTexture() [2/5]

◆ updateBackendTexture() [3/5]

◆ updateBackendTexture() [4/5]