GrGpu Class Reference

#include <GrGpu.h>

Inheritance diagram for GrGpu:

Classes
class	Stats

Public Types
enum class	DisconnectType { kAbandon , kCleanup }

Public Member Functions
	GrGpu (GrDirectContext *direct)
virtual	~GrGpu ()
GrDirectContext *	getContext ()
const GrDirectContext *	getContext () const
const GrCaps *	caps () const
sk_sp< const GrCaps >	refCaps () const
virtual GrStagingBufferManager *	stagingBufferManager ()
virtual GrRingBuffer *	uniformsRingBuffer ()
virtual void	disconnect (DisconnectType)
virtual GrThreadSafePipelineBuilder *	pipelineBuilder ()=0
virtual sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder ()=0
virtual bool	isDeviceLost () const
void	markContextDirty (uint32_t state=kAll_GrBackendState)
sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Budgeted budgeted, GrProtected isProtected, GrColorType textureColorType, GrColorType srcColorType, const GrMipLevel texels[], int texelLevelCount, std::string_view label)
sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Mipmapped mipmapped, skgpu::Budgeted budgeted, GrProtected isProtected, std::string_view label)
sk_sp< GrTexture >	createCompressedTexture (SkISize dimensions, const GrBackendFormat &format, skgpu::Budgeted budgeted, skgpu::Mipmapped mipmapped, GrProtected isProtected, const void *data, size_t dataSize)
sk_sp< GrTexture >	wrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType)
sk_sp< GrTexture >	wrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable)
sk_sp< GrTexture >	wrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable)
sk_sp< GrRenderTarget >	wrapBackendRenderTarget (const GrBackendRenderTarget &)
sk_sp< GrRenderTarget >	wrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)
sk_sp< GrGpuBuffer >	createBuffer (size_t size, GrGpuBufferType intendedType, GrAccessPattern accessPattern)
void	resolveRenderTarget (GrRenderTarget *, const SkIRect &resolveRect)
bool	regenerateMipMapLevels (GrTexture *)
void	resetTextureBindings ()
bool	readPixels (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType dstColorType, void *buffer, size_t rowBytes)
bool	writePixels (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const GrMipLevel texels[], int mipLevelCount, bool prepForTexSampling=false)
bool	writePixels (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const void *buffer, size_t rowBytes, bool prepForTexSampling=false)
bool	transferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size)
bool	transferPixelsTo (GrTexture *texture, SkIRect rect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset, size_t rowBytes)
bool	transferPixelsFrom (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset)
bool	copySurface (GrSurface *dst, const SkIRect &dstRect, GrSurface *src, const SkIRect &srcRect, GrSamplerState::Filter filter)
GrOpsRenderPass *	getOpsRenderPass (GrRenderTarget *renderTarget, bool useMSAASurface, GrAttachment *stencil, GrSurfaceOrigin, const SkIRect &bounds, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers)
void	executeFlushInfo (SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess access, const GrFlushInfo &, const skgpu::MutableTextureState *newState)
virtual void	willExecute ()
bool	submitToGpu (GrSyncCpu sync)
virtual void	submit (GrOpsRenderPass *)=0
virtual std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned=true)=0
virtual std::unique_ptr< GrSemaphore >	wrapBackendSemaphore (const GrBackendSemaphore &, GrSemaphoreWrapType, GrWrapOwnership)=0
virtual void	insertSemaphore (GrSemaphore *semaphore)=0
virtual void	waitSemaphore (GrSemaphore *semaphore)=0
virtual void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)=0
virtual void	checkFinishProcs ()=0
virtual void	finishOutstandingGpuWork ()=0
virtual void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)
bool	checkAndResetOOMed ()
virtual std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *)=0
virtual void	releaseUnlockedBackendObjects ()
Stats *	stats ()
void	dumpJSON (SkJSONWriter *) const
GrBackendTexture	createBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label)
bool	clearBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, std::array< float, 4 > color)
GrBackendTexture	createCompressedBackendTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, GrProtected)
bool	updateCompressedBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t length)
virtual bool	setBackendTextureState (const GrBackendTexture &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)
virtual bool	setBackendRenderTargetState (const GrBackendRenderTarget &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)
virtual void	deleteBackendTexture (const GrBackendTexture &)=0
virtual bool	compile (const GrProgramDesc &, const GrProgramInfo &)=0
virtual bool	precompileShader (const SkData &key, const SkData &data)
virtual sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &colorFormat, SkISize dimensions, int numStencilSamples)=0
virtual GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &)=0
virtual sk_sp< GrAttachment >	makeMSAAAttachment (SkISize dimensions, const GrBackendFormat &format, int numSamples, GrProtected isProtected, GrMemoryless isMemoryless)=0
void	handleDirtyContext ()
virtual void	storeVkPipelineCacheData ()
virtual void	xferBarrier (GrRenderTarget *, GrXferBarrierType)=0

Protected Member Functions
void	didWriteToSurface (GrSurface *surface, GrSurfaceOrigin origin, const SkIRect *bounds, uint32_t mipLevels=1) const
void	setOOMed ()
void	initCaps (sk_sp< const GrCaps > caps)

Static Protected Member Functions
static bool	CompressedDataIsCorrect (SkISize dimensions, SkTextureCompressionType, skgpu::Mipmapped, const void *data, size_t length)

Protected Attributes
Stats	fStats

Private Member Functions
virtual GrBackendTexture	onCreateBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label)=0
virtual GrBackendTexture	onCreateCompressedBackendTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, GrProtected)=0
virtual bool	onClearBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, std::array< float, 4 > color)=0
virtual bool	onUpdateCompressedBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t length)=0
virtual void	onResetContext (uint32_t resetBits)
virtual void	onResetTextureBindings ()
virtual sk_sp< GrTexture >	onCreateTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, int renderTargetSampleCnt, skgpu::Budgeted, GrProtected, int mipLevelCoont, uint32_t levelClearMask, std::string_view label)=0
virtual sk_sp< GrTexture >	onCreateCompressedTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Budgeted, skgpu::Mipmapped, GrProtected, const void *data, size_t dataSize)=0
virtual sk_sp< GrTexture >	onWrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType)=0
virtual sk_sp< GrTexture >	onWrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable)=0
virtual sk_sp< GrTexture >	onWrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable)=0
virtual sk_sp< GrRenderTarget >	onWrapBackendRenderTarget (const GrBackendRenderTarget &)=0
virtual sk_sp< GrRenderTarget >	onWrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)
virtual sk_sp< GrGpuBuffer >	onCreateBuffer (size_t size, GrGpuBufferType intendedType, GrAccessPattern)=0
virtual bool	onReadPixels (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType dstColorType, void *, size_t rowBytes)=0
virtual bool	onWritePixels (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType srcColorType, const GrMipLevel[], int mipLevelCount, bool prepForTexSampling)=0
virtual bool	onTransferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size)=0
virtual bool	onTransferPixelsTo (GrTexture *, SkIRect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset, size_t rowBytes)=0
virtual bool	onTransferPixelsFrom (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset)=0
virtual void	onResolveRenderTarget (GrRenderTarget *target, const SkIRect &resolveRect)=0
virtual bool	onRegenerateMipMapLevels (GrTexture *)=0
virtual bool	onCopySurface (GrSurface *dst, const SkIRect &dstRect, GrSurface *src, const SkIRect &srcRect, GrSamplerState::Filter)=0
virtual GrOpsRenderPass *	onGetOpsRenderPass (GrRenderTarget *renderTarget, bool useMSAASurface, GrAttachment *stencil, GrSurfaceOrigin, const SkIRect &bounds, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers)=0
virtual void	prepareSurfacesForBackendAccessAndStateUpdates (SkSpan< GrSurfaceProxy * > proxies, SkSurfaces::BackendSurfaceAccess access, const skgpu::MutableTextureState *newState)
virtual bool	onSubmitToGpu (GrSyncCpu sync)=0
virtual void	onReportSubmitHistograms ()

Detailed Description

Definition at line 62 of file GrGpu.h.

Member Enumeration Documentation

DisconnectType

enum class GrGpu::DisconnectType

strong

Enumerator
kAbandon
kCleanup

Definition at line 80 of file GrGpu.h.

                              {
        // No cleanup should be attempted, immediately cease making backend API calls
        kAbandon,
        // Free allocated resources (not known by GrResourceCache) before returning and
        // ensure no backend backend 3D API calls will be made after disconnect() returns.
        kCleanup,
    };

Constructor & Destructor Documentation

GrGpu()

GrGpu::GrGpu

(

GrDirectContext *

direct

)

Definition at line 41 of file GrGpu.cpp.

: fResetBits(kAll_GrBackendState), fContext(direct) {}

~GrGpu()

GrGpu::~GrGpu ( )

virtual

Definition at line 43 of file GrGpu.cpp.

              {
    this->callSubmittedProcs(false);
}

Member Function Documentation

addFinishedProc()

virtual void GrGpu::addFinishedProc ( GrGpuFinishedProc  finishedProc, GrGpuFinishedContext  finishedContext  )

pure virtual

caps()

const GrCaps * GrGpu::caps ( ) const

inline

Gets the capabilities of the draw target.

Definition at line 73 of file GrGpu.h.

{ return fCaps.get(); }

checkAndResetOOMed()

bool GrGpu::checkAndResetOOMed

(

)

Checks if we detected an OOM from the underlying 3D API and if so returns true and resets the internal OOM state to false. Otherwise, returns false.

Definition at line 783 of file GrGpu.cpp.

                               {
    if (fOOMed) {
        fOOMed = false;
        return true;
    }
    return false;
}

checkFinishProcs()

virtual void GrGpu::checkFinishProcs ( )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

clearBackendTexture()

bool GrGpu::clearBackendTexture	(	const GrBackendTexture &	backendTexture,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback,
		std::array< float, 4 >	color
	)

Definition at line 898 of file GrGpu.cpp.

                                                          {
    if (!backendTexture.isValid()) {
        return false;
    }
 
    if (backendTexture.hasMipmaps() && !this->caps()->mipmapSupport()) {
        return false;
    }
 
    return this->onClearBackendTexture(backendTexture, std::move(finishedCallback), color);
}

compile()

virtual bool GrGpu::compile ( const GrProgramDesc &  , const GrProgramInfo &    )

pure virtual

In this case we have a program descriptor and a program info but no render target.

Implemented in GrD3DGpu, GrGLGpu, GrMtlGpu, and GrVkGpu.

CompressedDataIsCorrect()

bool GrGpu::CompressedDataIsCorrect ( SkISize  dimensions, SkTextureCompressionType  compressionType, skgpu::Mipmapped  mipmapped, const void *  data, size_t  length  )

staticprotected

Definition at line 858 of file GrGpu.cpp.

                                                   {
    size_t computedSize = SkCompressedDataSize(
            compressionType, dimensions, nullptr, mipmapped == skgpu::Mipmapped::kYes);
    return computedSize == length;
}

copySurface()

bool GrGpu::copySurface	(	GrSurface *	dst,
		const SkIRect &	dstRect,
		GrSurface *	src,
		const SkIRect &	srcRect,
		GrSamplerState::Filter	filter
	)

Definition at line 410 of file GrGpu.cpp.

                                                     {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(dst && src);
    SkASSERT(!src->framebufferOnly());
 
    if (dst->readOnly()) {
        return false;
    }
 
    this->handleDirtyContext();
 
    return this->onCopySurface(dst, dstRect, src, srcRect, filter);
}

createBackendTexture()

GrBackendTexture GrGpu::createBackendTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrRenderable	renderable,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		std::string_view	label
	)

Creates a texture directly in the backend API without wrapping it in a GrTexture. Must be matched with a call to deleteBackendTexture().

If data is null the texture is uninitialized.

If data represents a color then all texture levels are cleared to that color.

If data represents pixmaps then it must have a either one pixmap or, if mipmapping is specified, a complete MIP hierarchy of pixmaps. Additionally, if provided, the mip levels must be sized correctly according to the MIP sizes implied by dimensions. They must all have the same color type and that color type must be compatible with the texture format.

Definition at line 868 of file GrGpu.cpp.

                                                                   {
    const GrCaps* caps = this->caps();
 
    if (!format.isValid()) {
        return {};
    }
 
    if (caps->isFormatCompressed(format)) {
        // Compressed formats must go through the createCompressedBackendTexture API
        return {};
    }
 
    if (dimensions.isEmpty() || dimensions.width()  > caps->maxTextureSize() ||
                                dimensions.height() > caps->maxTextureSize()) {
        return {};
    }
 
    if (mipmapped == skgpu::Mipmapped::kYes && !this->caps()->mipmapSupport()) {
        return {};
    }
 
    return this->onCreateBackendTexture(
            dimensions, format, renderable, mipmapped, isProtected, label);
}

createBuffer()

sk_sp< GrGpuBuffer > GrGpu::createBuffer	(	size_t	size,
		GrGpuBufferType	intendedType,
		GrAccessPattern	accessPattern
	)

Creates a buffer in GPU memory. For a client-side buffer use GrBuffer::CreateCPUBacked.

Parameters

size	size of buffer to create.
intendedType	hint to the graphics subsystem about what the buffer will be used for.
accessPattern	hint to the graphics subsystem about how the data will be accessed.

Returns

the buffer if successful, otherwise nullptr.

Definition at line 393 of file GrGpu.cpp.

                                                                      {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    this->handleDirtyContext();
    if ((intendedType == GrGpuBufferType::kXferCpuToGpu ||
         intendedType == GrGpuBufferType::kXferGpuToCpu) &&
        accessPattern == kStatic_GrAccessPattern) {
        return nullptr;
    }
    sk_sp<GrGpuBuffer> buffer = this->onCreateBuffer(size, intendedType, accessPattern);
    if (buffer && !this->caps()->reuseScratchBuffers()) {
        buffer->resourcePriv().removeScratchKey();
    }
    return buffer;
}

createCompressedBackendTexture()

GrBackendTexture GrGpu::createCompressedBackendTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected
	)

Same as the createBackendTexture case except compressed backend textures can never be renderable.

Definition at line 912 of file GrGpu.cpp.

                                                                                {
    const GrCaps* caps = this->caps();
 
    if (!format.isValid()) {
        return {};
    }
 
    SkTextureCompressionType compressionType = GrBackendFormatToCompressionType(format);
    if (compressionType == SkTextureCompressionType::kNone) {
        // Uncompressed formats must go through the createBackendTexture API
        return {};
    }
 
    if (dimensions.isEmpty() ||
        dimensions.width()  > caps->maxTextureSize() ||
        dimensions.height() > caps->maxTextureSize()) {
        return {};
    }
 
    if (mipmapped == skgpu::Mipmapped::kYes && !this->caps()->mipmapSupport()) {
        return {};
    }
 
    return this->onCreateCompressedBackendTexture(dimensions, format, mipmapped, isProtected);
}

createCompressedTexture()

sk_sp< GrTexture > GrGpu::createCompressedTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		skgpu::Budgeted	budgeted,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const void *	data,
		size_t	dataSize
	)

Definition at line 260 of file GrGpu.cpp.

                                                                 {
    this->handleDirtyContext();
    if (dimensions.width()  < 1 || dimensions.width()  > this->caps()->maxTextureSize() ||
        dimensions.height() < 1 || dimensions.height() > this->caps()->maxTextureSize()) {
        return nullptr;
    }
    // Note if we relax the requirement that data must be provided then we must check
    // caps()->shouldInitializeTextures() here.
    if (!data) {
        return nullptr;
    }
 
    // TODO: expand CompressedDataIsCorrect to work here too
    SkTextureCompressionType compressionType = GrBackendFormatToCompressionType(format);
    if (compressionType == SkTextureCompressionType::kNone) {
        return nullptr;
    }
 
    if (!this->caps()->isFormatTexturable(format, GrTextureType::k2D)) {
        return nullptr;
    }
 
    if (dataSize <
        SkCompressedDataSize(
                compressionType, dimensions, nullptr, mipmapped == skgpu::Mipmapped::kYes)) {
        return nullptr;
    }
    return this->onCreateCompressedTexture(dimensions, format, budgeted, mipmapped, isProtected,
                                           data, dataSize);
}

createTexture() [1/2]

sk_sp< GrTexture > GrGpu::createTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrTextureType	textureType,
		GrRenderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		GrColorType	textureColorType,
		GrColorType	srcColorType,
		const GrMipLevel	texels[],
		int	texelLevelCount,
		std::string_view	label
	)

Creates a texture object. If renderable is kYes then the returned texture can be used as a render target by calling GrTexture::asRenderTarget(). Not all pixel configs can be used as render targets. Support for configs as textures or render targets can be checked using GrCaps.

Parameters

dimensions	dimensions of the texture to be created.
format	the format for the texture (not currently used).
renderable	should the resulting texture be renderable
renderTargetSampleCnt	The number of samples to use for rendering if renderable is kYes. If renderable is kNo then this must be 1.
budgeted	does this texture count against the resource cache budget?
isProtected	should the texture be created as protected.
texels	array of mipmap levels containing texel data to load. If level i has pixels then it is assumed that its dimensions are max(1, floor(dimensions.fWidth / 2)) by max(1, floor(dimensions.fHeight / 2)). If texels[i].fPixels == nullptr for all i <= mipLevelCount or mipLevelCount is 0 then the texture's contents are uninitialized. If a level has non-null pixels, its row bytes must be a multiple of the config's bytes-per-pixel. The row bytes must be tight to the level width if !caps->writePixelsRowBytesSupport(). If mipLevelCount > 1 and texels[i].fPixels != nullptr for any i > 0 then all levels must have non-null pixels. All levels must have non-null pixels if GrCaps::createTextureMustSpecifyAllLevels() is true.
textureColorType	The color type interpretation of the texture for the purpose of of uploading texel data.
srcColorType	The color type of data in texels[].
texelLevelCount	the number of levels in 'texels'. May be 0, 1, or floor(max((log2(dimensions.fWidth), log2(dimensions.fHeight)))). It must be the latter if GrCaps::createTextureMustSpecifyAllLevels() is true.

Returns

The texture object if successful, otherwise nullptr.

Definition at line 189 of file GrGpu.cpp.

                                                            {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    if (texelLevelCount) {
        if (!validate_texel_levels(dimensions, srcColorType, texels, texelLevelCount,
                                   this->caps())) {
            return nullptr;
        }
    }
 
    int mipLevelCount = std::max(1, texelLevelCount);
    uint32_t levelClearMask = 0;
    if (this->caps()->shouldInitializeTextures()) {
        if (texelLevelCount) {
            for (int i = 0; i < mipLevelCount; ++i) {
                if (!texels->fPixels) {
                    levelClearMask |= static_cast<uint32_t>(1 << i);
                }
            }
        } else {
            levelClearMask = static_cast<uint32_t>((1 << mipLevelCount) - 1);
        }
    }
 
    auto tex = this->createTextureCommon(dimensions,
                                         format,
                                         textureType,
                                         renderable,
                                         renderTargetSampleCnt,
                                         budgeted,
                                         isProtected,
                                         texelLevelCount,
                                         levelClearMask,
                                         label);
    if (tex) {
        bool markMipLevelsClean = false;
        // Currently if level 0 does not have pixels then no other level may, as enforced by
        // validate_texel_levels.
        if (texelLevelCount && texels[0].fPixels) {
            if (!this->writePixels(tex.get(),
                                   SkIRect::MakeSize(dimensions),
                                   textureColorType,
                                   srcColorType,
                                   texels,
                                   texelLevelCount)) {
                return nullptr;
            }
            // Currently if level[1] of mip map has pixel data then so must all other levels.
            // as enforced by validate_texel_levels.
            markMipLevelsClean = (texelLevelCount > 1 && !levelClearMask && texels[1].fPixels);
            fStats.incTextureUploads();
        } else if (levelClearMask && mipLevelCount > 1) {
            markMipLevelsClean = true;
        }
        if (markMipLevelsClean) {
            tex->markMipmapsClean();
        }
    }
    return tex;
}

createTexture() [2/2]

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

Simplified createTexture() interface for when there is no initial texel data to upload.

Definition at line 156 of file GrGpu.cpp.

                                                            {
    int mipLevelCount = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        mipLevelCount =
                32 - SkCLZ(static_cast<uint32_t>(std::max(dimensions.fWidth, dimensions.fHeight)));
    }
    uint32_t levelClearMask =
            this->caps()->shouldInitializeTextures() ? (1 << mipLevelCount) - 1 : 0;
    auto tex = this->createTextureCommon(dimensions,
                                         format,
                                         textureType,
                                         renderable,
                                         renderTargetSampleCnt,
                                         budgeted,
                                         isProtected,
                                         mipLevelCount,
                                         levelClearMask,
                                         label);
    if (tex && mipmapped == skgpu::Mipmapped::kYes && levelClearMask) {
        tex->markMipmapsClean();
    }
 
    return tex;
}

deleteBackendTexture()

virtual void GrGpu::deleteBackendTexture ( const GrBackendTexture &  )

pure virtual

Frees a texture created by createBackendTexture(). If ownership of the backend texture has been transferred to a context using adopt semantics this should not be called.

Implemented in GrD3DGpu, GrGLGpu, GrMtlGpu, and GrVkGpu.

didWriteToSurface()

void GrGpu::didWriteToSurface ( GrSurface *  surface, GrSurfaceOrigin  origin, const SkIRect *  bounds, uint32_t  mipLevels = 1  ) const

protected

Definition at line 665 of file GrGpu.cpp.

                                                        {
    SkASSERT(surface);
    SkASSERT(!surface->readOnly());
    // Mark any MIP chain as dirty if and only if there is a non-empty bounds.
    if (nullptr == bounds || !bounds->isEmpty()) {
        GrTexture* texture = surface->asTexture();
        if (texture) {
            if (mipLevels == 1) {
                texture->markMipmapsDirty();
            } else {
                texture->markMipmapsClean();
            }
        }
    }
}

disconnect()

void GrGpu::disconnect ( DisconnectType  type )

virtual

Reimplemented in GrGLGpu, GrMtlGpu, and GrVkGpu.

Definition at line 51 of file GrGpu.cpp.

{}

dumpJSON()

void GrGpu::dumpJSON

(

SkJSONWriter *

writer

)

const

Definition at line 811 of file GrGpu.cpp.

{ }

executeFlushInfo()

void GrGpu::executeFlushInfo	(	SkSpan< GrSurfaceProxy * >	proxies,
		SkSurfaces::BackendSurfaceAccess	access,
		const GrFlushInfo &	info,
		const skgpu::MutableTextureState *	newState
	)

Definition at line 682 of file GrGpu.cpp.

                                                                       {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    GrResourceProvider* resourceProvider = fContext->priv().resourceProvider();
 
    std::unique_ptr<std::unique_ptr<GrSemaphore>[]> semaphores(
            new std::unique_ptr<GrSemaphore>[info.fNumSemaphores]);
    if (this->caps()->backendSemaphoreSupport() && info.fNumSemaphores) {
        for (size_t i = 0; i < info.fNumSemaphores; ++i) {
            if (info.fSignalSemaphores[i].isInitialized()) {
                semaphores[i] = resourceProvider->wrapBackendSemaphore(
                    info.fSignalSemaphores[i],
                    GrSemaphoreWrapType::kWillSignal,
                    kBorrow_GrWrapOwnership);
                // 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 signal it.
                if (semaphores[i]) {
                    this->insertSemaphore(semaphores[i].get());
                }
            } else {
                semaphores[i] = resourceProvider->makeSemaphore(false);
                if (semaphores[i]) {
                    this->insertSemaphore(semaphores[i].get());
                    info.fSignalSemaphores[i] = semaphores[i]->backendSemaphore();
                }
            }
        }
    }
 
    if (info.fFinishedProc) {
        this->addFinishedProc(info.fFinishedProc, info.fFinishedContext);
    }
 
    if (info.fSubmittedProc) {
        fSubmittedProcs.emplace_back(info.fSubmittedProc, info.fSubmittedContext);
    }
 
    // We currently don't support passing in new surface state for multiple proxies here. The only
    // time we have multiple proxies is if we are flushing a yuv SkImage which won't have state
    // updates anyways.
    SkASSERT(!newState || proxies.size() == 1);
    SkASSERT(!newState || access == SkSurfaces::BackendSurfaceAccess::kNoAccess);
    this->prepareSurfacesForBackendAccessAndStateUpdates(proxies, access, newState);
}

finishOutstandingGpuWork()

virtual void GrGpu::finishOutstandingGpuWork ( )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

getContext() [1/2]

GrDirectContext * GrGpu::getContext ( )

inline

Definition at line 67 of file GrGpu.h.

{ return fContext; }

getContext() [2/2]

const GrDirectContext * GrGpu::getContext ( ) const

inline

Definition at line 68 of file GrGpu.h.

{ return fContext; }

getOpsRenderPass()

GrOpsRenderPass * GrGpu::getOpsRenderPass	(	GrRenderTarget *	renderTarget,
		bool	useMSAASurface,
		GrAttachment *	stencil,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorInfo,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilInfo,
		const skia_private::TArray< GrSurfaceProxy *, true > &	sampledProxies,
		GrXferBarrierFlags	renderPassXferBarriers
	)

Definition at line 730 of file GrGpu.cpp.

                                                   {
#if SK_HISTOGRAMS_ENABLED
    fCurrentSubmitRenderPassCount++;
#endif
    fStats.incRenderPasses();
    return this->onGetOpsRenderPass(renderTarget, useMSAASurface, stencil, origin, bounds,
                                    colorInfo, stencilInfo, sampledProxies, renderPassXferBarriers);
}

getPreferredStencilFormat()

virtual GrBackendFormat GrGpu::getPreferredStencilFormat ( const GrBackendFormat &  )

pure virtual

Implemented in GrD3DGpu, and GrVkGpu.

handleDirtyContext()

void GrGpu::handleDirtyContext ( )

inline

Definition at line 677 of file GrGpu.h.

                              {
        if (fResetBits) {
            this->resetContext();
        }
    }

initCaps()

void GrGpu::initCaps ( sk_sp< const GrCaps >  caps )

protected

Definition at line 47 of file GrGpu.cpp.

                                             {
    fCaps = std::move(caps);
}

insertSemaphore()

virtual void GrGpu::insertSemaphore ( GrSemaphore *  semaphore )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

isDeviceLost()

virtual bool GrGpu::isDeviceLost ( ) const

inlinevirtual

Reimplemented in GrVkGpu.

Definition at line 97 of file GrGpu.h.

{ return false; }

makeMSAAAttachment()

virtual sk_sp< GrAttachment > GrGpu::makeMSAAAttachment ( SkISize  dimensions, const GrBackendFormat &  format, int  numSamples, GrProtected  isProtected, GrMemoryless  isMemoryless  )

pure virtual

Implemented in GrD3DGpu, GrVkGpu, and GrGLGpu.

makeSemaphore()

virtual std::unique_ptr< GrSemaphore > GrGpu::makeSemaphore ( bool  isOwned = true )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

makeStencilAttachment()

virtual sk_sp< GrAttachment > GrGpu::makeStencilAttachment ( const GrBackendFormat &  colorFormat, SkISize  dimensions, int  numStencilSamples  )

pure virtual

Implemented in GrD3DGpu, GrVkGpu, and GrGLGpu.

markContextDirty()

void GrGpu::markContextDirty ( uint32_t  state = kAll_GrBackendState )

inline

The GrGpu object normally assumes that no outsider is setting state within the underlying 3D API's context/device/whatever. This call informs the GrGpu that the state was modified and it shouldn't make assumptions about the state.

Definition at line 105 of file GrGpu.h.

{ fResetBits |= state; }

onClearBackendTexture()

virtual bool GrGpu::onClearBackendTexture ( const GrBackendTexture &  , sk_sp< skgpu::RefCntedCallback >  finishedCallback, std::array< float, 4 >  color  )

privatepure virtual

onCopySurface()

virtual bool GrGpu::onCopySurface ( GrSurface *  dst, const SkIRect &  dstRect, GrSurface *  src, const SkIRect &  srcRect, GrSamplerState::Filter    )

privatepure virtual

Implemented in GrMtlGpu.

onCreateBackendTexture()

virtual GrBackendTexture GrGpu::onCreateBackendTexture ( SkISize  dimensions, const GrBackendFormat &  , GrRenderable  , skgpu::Mipmapped  , GrProtected  , std::string_view  label  )

privatepure virtual

onCreateBuffer()

virtual sk_sp< GrGpuBuffer > GrGpu::onCreateBuffer ( size_t  size, GrGpuBufferType  intendedType, GrAccessPattern    )

privatepure virtual

onCreateCompressedBackendTexture()

virtual GrBackendTexture GrGpu::onCreateCompressedBackendTexture ( SkISize  dimensions, const GrBackendFormat &  , skgpu::Mipmapped  , GrProtected    )

privatepure virtual

onCreateCompressedTexture()

virtual sk_sp< GrTexture > GrGpu::onCreateCompressedTexture ( SkISize  dimensions, const GrBackendFormat &  , skgpu::Budgeted  , skgpu::Mipmapped  , GrProtected  , const void *  data, size_t  dataSize  )

privatepure virtual

onCreateTexture()

virtual sk_sp< GrTexture > GrGpu::onCreateTexture ( SkISize  dimensions, const GrBackendFormat &  , GrRenderable  , int  renderTargetSampleCnt, skgpu::Budgeted  , GrProtected  , int  mipLevelCoont, uint32_t  levelClearMask, std::string_view  label  )

privatepure virtual

onGetOpsRenderPass()

virtual GrOpsRenderPass * GrGpu::onGetOpsRenderPass ( GrRenderTarget *  renderTarget, bool  useMSAASurface, GrAttachment *  stencil, GrSurfaceOrigin  , const SkIRect &  bounds, const GrOpsRenderPass::LoadAndStoreInfo &  , const GrOpsRenderPass::StencilLoadAndStoreInfo &  , const skia_private::TArray< GrSurfaceProxy *, true > &  sampledProxies, GrXferBarrierFlags  renderPassXferBarriers  )

privatepure virtual

onReadPixels()

virtual bool GrGpu::onReadPixels ( GrSurface *  , SkIRect  , GrColorType  surfaceColorType, GrColorType  dstColorType, void *  , size_t  rowBytes  )

privatepure virtual

onRegenerateMipMapLevels()

virtual bool GrGpu::onRegenerateMipMapLevels ( GrTexture *  )

privatepure virtual

Implemented in GrVkGpu.

onReportSubmitHistograms()

virtual void GrGpu::onReportSubmitHistograms ( )

inlineprivatevirtual

Definition at line 849 of file GrGpu.h.

{}

onResetContext()

virtual void GrGpu::onResetContext ( uint32_t  resetBits )

inlineprivatevirtual

Definition at line 732 of file GrGpu.h.

{}

onResetTextureBindings()

virtual void GrGpu::onResetTextureBindings ( )

inlineprivatevirtual

Definition at line 735 of file GrGpu.h.

{}

onResolveRenderTarget()

virtual void GrGpu::onResolveRenderTarget ( GrRenderTarget *  target, const SkIRect &  resolveRect  )

privatepure virtual

Implemented in GrVkGpu.

onSubmitToGpu()

virtual bool GrGpu::onSubmitToGpu ( GrSyncCpu  sync )

privatepure virtual

onTransferFromBufferToBuffer()

virtual bool GrGpu::onTransferFromBufferToBuffer ( sk_sp< GrGpuBuffer >  src, size_t  srcOffset, sk_sp< GrGpuBuffer >  dst, size_t  dstOffset, size_t  size  )

privatepure virtual

onTransferPixelsFrom()

virtual bool GrGpu::onTransferPixelsFrom ( GrSurface *  , SkIRect  , GrColorType  surfaceColorType, GrColorType  bufferColorType, sk_sp< GrGpuBuffer >  transferBuffer, size_t  offset  )

privatepure virtual

onTransferPixelsTo()

virtual bool GrGpu::onTransferPixelsTo ( GrTexture *  , SkIRect  , GrColorType  textureColorType, GrColorType  bufferColorType, sk_sp< GrGpuBuffer >  transferBuffer, size_t  offset, size_t  rowBytes  )

privatepure virtual

onUpdateCompressedBackendTexture()

virtual bool GrGpu::onUpdateCompressedBackendTexture ( const GrBackendTexture &  , sk_sp< skgpu::RefCntedCallback >  finishedCallback, const void *  data, size_t  length  )

privatepure virtual

onWrapBackendRenderTarget()

virtual sk_sp< GrRenderTarget > GrGpu::onWrapBackendRenderTarget ( const GrBackendRenderTarget &  )

privatepure virtual

onWrapBackendTexture()

virtual sk_sp< GrTexture > GrGpu::onWrapBackendTexture ( const GrBackendTexture &  , GrWrapOwnership  , GrWrapCacheable  , GrIOType    )

privatepure virtual

onWrapCompressedBackendTexture()

virtual sk_sp< GrTexture > GrGpu::onWrapCompressedBackendTexture ( const GrBackendTexture &  , GrWrapOwnership  , GrWrapCacheable    )

privatepure virtual

onWrapRenderableBackendTexture()

virtual sk_sp< GrTexture > GrGpu::onWrapRenderableBackendTexture ( const GrBackendTexture &  , int  sampleCnt, GrWrapOwnership  , GrWrapCacheable    )

privatepure virtual

onWrapVulkanSecondaryCBAsRenderTarget()

sk_sp< GrRenderTarget > GrGpu::onWrapVulkanSecondaryCBAsRenderTarget ( const SkImageInfo &  imageInfo, const GrVkDrawableInfo &  vkInfo  )

privatevirtual

Definition at line 387 of file GrGpu.cpp.

                                                                                                   {
    // This is only supported on Vulkan so we default to returning nullptr here
    return nullptr;
}

onWritePixels()

virtual bool GrGpu::onWritePixels ( GrSurface *  , SkIRect  , GrColorType  surfaceColorType, GrColorType  srcColorType, const  GrMipLevel[], int  mipLevelCount, bool  prepForTexSampling  )

privatepure virtual

pipelineBuilder()

virtual GrThreadSafePipelineBuilder * GrGpu::pipelineBuilder ( )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

precompileShader()

virtual bool GrGpu::precompileShader ( const SkData &  key, const SkData &  data  )

inlinevirtual

Reimplemented in GrGLGpu, and GrMtlGpu.

Definition at line 621 of file GrGpu.h.

{ return false; }

prepareSurfacesForBackendAccessAndStateUpdates()

virtual void GrGpu::prepareSurfacesForBackendAccessAndStateUpdates ( SkSpan< GrSurfaceProxy * >  proxies, SkSurfaces::BackendSurfaceAccess  access, const skgpu::MutableTextureState *  newState  )

inlineprivatevirtual

Definition at line 841 of file GrGpu.h.

                                                      {}

prepareTextureForCrossContextUsage()

virtual std::unique_ptr< GrSemaphore > GrGpu::prepareTextureForCrossContextUsage ( GrTexture *  )

pure virtual

Put this texture in a safe and known state for use across multiple contexts. Depending on the backend, this may return a GrSemaphore. If so, other contexts should wait on that semaphore before using this texture.

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

readPixels()

bool GrGpu::readPixels	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	dstColorType,
		void *	buffer,
		size_t	rowBytes
	)

Reads a rectangle of pixels from a render target. No sRGB/linear conversions are performed.

Parameters

surface	the surface to read from
rect	the rectangle of pixels to read
surfaceColorType	the color type for this use of the surface.
dstColorType	the color type of the destination buffer.
buffer	memory to read the rectangle into.
rowBytes	the number of bytes between consecutive rows. Must be a multiple of dstColorType's bytes-per-pixel. Must be tight to width if !caps->readPixelsRowBytesSupport().

Returns

true if the read succeeded, false if not. The read can fail because of the surface doesn't support reading, the color type is not allowed for the format of the surface or if the rectangle read is not contained in the surface.

Definition at line 426 of file GrGpu.cpp.

                                        {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(surface);
    SkASSERT(!surface->framebufferOnly());
    SkASSERT(this->caps()->areColorTypeAndFormatCompatible(surfaceColorType,
                                                           surface->backendFormat()));
 
    if (!SkIRect::MakeSize(surface->dimensions()).contains(rect)) {
        return false;
    }
 
    size_t minRowBytes = SkToSizeT(GrColorTypeBytesPerPixel(dstColorType) * rect.width());
    if (!this->caps()->readPixelsRowBytesSupport()) {
        if (rowBytes != minRowBytes) {
            return false;
        }
    } else {
        if (rowBytes < minRowBytes) {
            return false;
        }
        if (rowBytes % GrColorTypeBytesPerPixel(dstColorType)) {
            return false;
        }
    }
 
    this->handleDirtyContext();
 
    return this->onReadPixels(surface, rect, surfaceColorType, dstColorType, buffer, rowBytes);
}

refCaps()

sk_sp< const GrCaps > GrGpu::refCaps ( ) const

inline

Definition at line 74 of file GrGpu.h.

{ return fCaps; }

refPipelineBuilder()

virtual sk_sp< GrThreadSafePipelineBuilder > GrGpu::refPipelineBuilder ( )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

regenerateMipMapLevels()

bool GrGpu::regenerateMipMapLevels

(

GrTexture *

texture

)

Uses the base of the texture to recompute the contents of the other levels.

Definition at line 632 of file GrGpu.cpp.

                                                     {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(texture);
    SkASSERT(this->caps()->mipmapSupport());
    SkASSERT(texture->mipmapped() == skgpu::Mipmapped::kYes);
    if (!texture->mipmapsAreDirty()) {
        // This can happen when the proxy expects mipmaps to be dirty, but they are not dirty on the
        // actual target. This may be caused by things that the drawingManager could not predict,
        // i.e., ops that don't draw anything, aborting a draw for exceptional circumstances, etc.
        // NOTE: This goes away once we quit tracking mipmap state on the actual texture.
        return true;
    }
    if (texture->readOnly()) {
        return false;
    }
    if (this->onRegenerateMipMapLevels(texture)) {
        texture->markMipmapsClean();
        return true;
    }
    return false;
}

releaseUnlockedBackendObjects()

virtual void GrGpu::releaseUnlockedBackendObjects ( )

inlinevirtual

Frees any backend specific objects that are not currently in use by the GPU. This is called when the client is trying to free up as much GPU memory as possible. We will not release resources connected to programs/pipelines since the cost to recreate those is significantly higher that other resources.

Reimplemented in GrVkGpu.

Definition at line 453 of file GrGpu.h.

{}

resetTextureBindings()

void GrGpu::resetTextureBindings

(

)

If the backend API has stateful texture bindings, this resets them back to defaults.

Definition at line 654 of file GrGpu.cpp.

                                 {
    this->handleDirtyContext();
    this->onResetTextureBindings();
}

resolveRenderTarget()

void GrGpu::resolveRenderTarget	(	GrRenderTarget *	target,
		const SkIRect &	resolveRect
	)

Resolves MSAA. The resolveRect must already be in the native destination space.

Definition at line 659 of file GrGpu.cpp.

                                                                                  {
    SkASSERT(target);
    this->handleDirtyContext();
    this->onResolveRenderTarget(target, resolveRect);
}

setBackendRenderTargetState()

virtual bool GrGpu::setBackendRenderTargetState ( const GrBackendRenderTarget &  , const skgpu::MutableTextureState &  , skgpu::MutableTextureState *  previousState, sk_sp< skgpu::RefCntedCallback >  finishedCallback  )

inlinevirtual

Reimplemented in GrVkGpu.

Definition at line 602 of file GrGpu.h.

                                                                                            {
        return false;
    }

setBackendTextureState()

virtual bool GrGpu::setBackendTextureState ( const GrBackendTexture &  , const skgpu::MutableTextureState &  , skgpu::MutableTextureState *  previousState, sk_sp< skgpu::RefCntedCallback >  finishedCallback  )

inlinevirtual

Reimplemented in GrVkGpu.

Definition at line 594 of file GrGpu.h.

                                                                                       {
        return false;
    }

setOOMed()

void GrGpu::setOOMed ( )

inlineprotected

Definition at line 701 of file GrGpu.h.

{ fOOMed = true; }

stagingBufferManager()

virtual GrStagingBufferManager * GrGpu::stagingBufferManager ( )

inlinevirtual

Reimplemented in GrD3DGpu, GrGLGpu, GrMtlGpu, and GrVkGpu.

Definition at line 76 of file GrGpu.h.

{ return nullptr; }

stats()

Stats * GrGpu::stats ( )

inline

Definition at line 551 of file GrGpu.h.

{ return &fStats; }

storeVkPipelineCacheData()

virtual void GrGpu::storeVkPipelineCacheData ( )

inlinevirtual

Reimplemented in GrVkGpu.

Definition at line 683 of file GrGpu.h.

{}

submit()

virtual void GrGpu::submit ( GrOpsRenderPass *  )

pure virtual

Implemented in GrVkGpu, GrD3DGpu, GrGLGpu, GrMockGpu, and GrMtlGpu.

submitToGpu()

bool GrGpu::submitToGpu

(

GrSyncCpu

sync

)

Definition at line 748 of file GrGpu.cpp.

                                      {
    this->stats()->incNumSubmitToGpus();
 
    if (auto manager = this->stagingBufferManager()) {
        manager->detachBuffers();
    }
 
    if (auto uniformsBuffer = this->uniformsRingBuffer()) {
        uniformsBuffer->startSubmit(this);
    }
 
    bool submitted = this->onSubmitToGpu(sync);
 
    this->callSubmittedProcs(submitted);
 
    this->reportSubmitHistograms();
 
    return submitted;
}

takeOwnershipOfBuffer()

virtual void GrGpu::takeOwnershipOfBuffer ( sk_sp< GrGpuBuffer >  )

inlinevirtual

Reimplemented in GrD3DGpu, and GrVkGpu.

Definition at line 432 of file GrGpu.h.

{}

transferFromBufferToBuffer()

bool GrGpu::transferFromBufferToBuffer	(	sk_sp< GrGpuBuffer >	src,
		size_t	srcOffset,
		sk_sp< GrGpuBuffer >	dst,
		size_t	dstOffset,
		size_t	size
	)

Transfer bytes from one GPU buffer to another. The src buffer must have type kXferCpuToGpu and the dst buffer must not. Neither buffer may currently be mapped. The offsets and size must be aligned to GrCaps::transferFromBufferToBufferAlignment.

Parameters

src	the buffer to read from
srcOffset	the aligned offset at the src at which the transfer begins.
dst	the buffer to write to
dstOffset	the aligned offset in the dst at which the transfer begins
size	the aligned number of bytes to transfer;

Definition at line 511 of file GrGpu.cpp.

                                                    {
    SkASSERT(src);
    SkASSERT(dst);
    SkASSERT(srcOffset % this->caps()->transferFromBufferToBufferAlignment() == 0);
    SkASSERT(dstOffset % this->caps()->transferFromBufferToBufferAlignment() == 0);
    SkASSERT(size      % this->caps()->transferFromBufferToBufferAlignment() == 0);
    SkASSERT(srcOffset + size <= src->size());
    SkASSERT(dstOffset + size <= dst->size());
    SkASSERT(src->intendedType() == GrGpuBufferType::kXferCpuToGpu);
    SkASSERT(dst->intendedType() != GrGpuBufferType::kXferCpuToGpu);
 
    this->handleDirtyContext();
    if (!this->onTransferFromBufferToBuffer(std::move(src),
                                            srcOffset,
                                            std::move(dst),
                                            dstOffset,
                                            size)) {
        return false;
    }
 
    fStats.incBufferTransfers();
 
    return true;
}

transferPixelsFrom()

bool GrGpu::transferPixelsFrom	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	bufferColorType,
		sk_sp< GrGpuBuffer >	transferBuffer,
		size_t	offset
	)

Reads the pixels from a rectangle of a surface into a buffer. Use GrCaps::SupportedRead::fOffsetAlignmentForTransferBuffer to determine the requirements for the buffer offset alignment. If the surface is a MIP mapped texture, the base level is read.

If successful the row bytes in the buffer is always: GrColorTypeBytesPerPixel(bufferColorType) * rect.width()

Asserts that the caller has passed a properly aligned offset and that the buffer is large enough to hold the result

Parameters

surface	the surface to read from.
rect	the rectangle of pixels to read
surfaceColorType	the color type for this use of the surface.
bufferColorType	the color type of the transfer buffer's pixel data
transferBuffer	GrBuffer to write pixels to (type must be "kXferGpuToCpu")
offset	offset from the start of the buffer

Definition at line 592 of file GrGpu.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(surface);
    SkASSERT(transferBuffer);
    SkASSERT(transferBuffer->intendedType() == GrGpuBufferType::kXferGpuToCpu);
    SkASSERT(this->caps()->areColorTypeAndFormatCompatible(surfaceColorType,
                                                           surface->backendFormat()));
 
#ifdef SK_DEBUG
    auto supportedRead = this->caps()->supportedReadPixelsColorType(
            surfaceColorType, surface->backendFormat(), bufferColorType);
    SkASSERT(supportedRead.fOffsetAlignmentForTransferBuffer);
    SkASSERT(offset % supportedRead.fOffsetAlignmentForTransferBuffer == 0);
#endif
 
    // We require that the write region is contained in the texture
    if (!SkIRect::MakeSize(surface->dimensions()).contains(rect)) {
        return false;
    }
 
    this->handleDirtyContext();
    if (!this->onTransferPixelsFrom(surface,
                                    rect,
                                    surfaceColorType,
                                    bufferColorType,
                                    std::move(transferBuffer),
                                    offset)) {
        return false;
    }
 
    fStats.incTransfersFromSurface();
 
    return true;
}

transferPixelsTo()

bool GrGpu::transferPixelsTo	(	GrTexture *	texture,
		SkIRect	rect,
		GrColorType	textureColorType,
		GrColorType	bufferColorType,
		sk_sp< GrGpuBuffer >	transferBuffer,
		size_t	offset,
		size_t	rowBytes
	)

Updates the pixels in a rectangle of a texture using a buffer. If the texture is MIP mapped, the base level is written to.

Parameters

texture	the texture to write to.
rect	the rectangle of pixels in the texture to overwrite
textureColorType	the color type for this use of the surface.
bufferColorType	the color type of the transfer buffer's pixel data
transferBuffer	GrBuffer to read pixels from (type must be "kXferCpuToGpu")
offset	offset from the start of the buffer
rowBytes	number of bytes between consecutive rows in the buffer. Must be a multiple of bufferColorType's bytes-per-pixel. Must be tight to rect.width() if !caps->writePixelsRowBytesSupport().

Definition at line 540 of file GrGpu.cpp.

                                              {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(texture);
    SkASSERT(transferBuffer);
    SkASSERT(transferBuffer->intendedType() == GrGpuBufferType::kXferCpuToGpu);
 
    if (texture->readOnly()) {
        return false;
    }
 
    // We require that the write region is contained in the texture
    if (!SkIRect::MakeSize(texture->dimensions()).contains(rect)) {
        return false;
    }
 
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    if (this->caps()->writePixelsRowBytesSupport()) {
        if (rowBytes < SkToSizeT(bpp*rect.width())) {
            return false;
        }
        if (rowBytes % bpp) {
            return false;
        }
    } else {
        if (rowBytes != SkToSizeT(bpp*rect.width())) {
            return false;
        }
    }
 
    this->handleDirtyContext();
    if (!this->onTransferPixelsTo(texture,
                                  rect,
                                  textureColorType,
                                  bufferColorType,
                                  std::move(transferBuffer),
                                  offset,
                                  rowBytes)) {
        return false;
    }
 
    this->didWriteToSurface(texture, kTopLeft_GrSurfaceOrigin, &rect);
    fStats.incTransfersToTexture();
 
    return true;
}

uniformsRingBuffer()

virtual GrRingBuffer * GrGpu::uniformsRingBuffer ( )

inlinevirtual

Reimplemented in GrD3DGpu, and GrMtlGpu.

Definition at line 78 of file GrGpu.h.

{ return nullptr; }

updateCompressedBackendTexture()

bool GrGpu::updateCompressedBackendTexture	(	const GrBackendTexture &	backendTexture,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback,
		const void *	data,
		size_t	length
	)

Definition at line 941 of file GrGpu.cpp.

                                                          {
    SkASSERT(data);
 
    if (!backendTexture.isValid()) {
        return false;
    }
 
    GrBackendFormat format = backendTexture.getBackendFormat();
 
    SkTextureCompressionType compressionType = GrBackendFormatToCompressionType(format);
    if (compressionType == SkTextureCompressionType::kNone) {
        // Uncompressed formats must go through the createBackendTexture API
        return false;
    }
 
    if (backendTexture.hasMipmaps() && !this->caps()->mipmapSupport()) {
        return false;
    }
 
    skgpu::Mipmapped mipmapped =
            backendTexture.hasMipmaps() ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
 
    if (!CompressedDataIsCorrect(backendTexture.dimensions(),
                                 compressionType,
                                 mipmapped,
                                 data,
                                 length)) {
        return false;
    }
 
    return this->onUpdateCompressedBackendTexture(backendTexture,
                                                  std::move(finishedCallback),
                                                  data,
                                                  length);
}

waitSemaphore()

virtual void GrGpu::waitSemaphore ( GrSemaphore *  semaphore )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

willExecute()

virtual void GrGpu::willExecute ( )

inlinevirtual

Reimplemented in GrGLGpu.

Definition at line 413 of file GrGpu.h.

{}

wrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrGpu::wrapBackendRenderTarget

(

const GrBackendRenderTarget &

backendRT

)

Implements GrResourceProvider::wrapBackendRenderTarget

Definition at line 366 of file GrGpu.cpp.

                                                                                           {
    this->handleDirtyContext();
 
    const GrCaps* caps = this->caps();
 
    if (!caps->isFormatRenderable(backendRT.getBackendFormat(), backendRT.sampleCnt())) {
        return nullptr;
    }
 
    sk_sp<GrRenderTarget> rt = this->onWrapBackendRenderTarget(backendRT);
    if (backendRT.isFramebufferOnly()) {
        rt->setFramebufferOnly();
    }
    return rt;
}

wrapBackendSemaphore()

virtual std::unique_ptr< GrSemaphore > GrGpu::wrapBackendSemaphore ( const GrBackendSemaphore &  , GrSemaphoreWrapType  , GrWrapOwnership    )

pure virtual

Implemented in GrD3DGpu, GrGLGpu, GrMockGpu, GrMtlGpu, and GrVkGpu.

wrapBackendTexture()

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

Implements GrResourceProvider::wrapBackendTexture

Definition at line 297 of file GrGpu.cpp.

                                                            {
    SkASSERT(ioType != kWrite_GrIOType);
    this->handleDirtyContext();
 
    const GrCaps* caps = this->caps();
    SkASSERT(caps);
 
    if (!caps->isFormatTexturable(backendTex.getBackendFormat(), backendTex.textureType())) {
        return nullptr;
    }
    if (backendTex.width() > caps->maxTextureSize() ||
        backendTex.height() > caps->maxTextureSize()) {
        return nullptr;
    }
 
    return this->onWrapBackendTexture(backendTex, ownership, cacheable, ioType);
}

wrapCompressedBackendTexture()

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

Definition at line 318 of file GrGpu.cpp.

                                                                                {
    this->handleDirtyContext();
 
    const GrCaps* caps = this->caps();
    SkASSERT(caps);
 
    if (!caps->isFormatTexturable(backendTex.getBackendFormat(), backendTex.textureType())) {
        return nullptr;
    }
    if (backendTex.width() > caps->maxTextureSize() ||
        backendTex.height() > caps->maxTextureSize()) {
        return nullptr;
    }
 
    return this->onWrapCompressedBackendTexture(backendTex, ownership, cacheable);
}

wrapRenderableBackendTexture()

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

Implements GrResourceProvider::wrapRenderableBackendTexture

Definition at line 337 of file GrGpu.cpp.

                                                                                {
    this->handleDirtyContext();
    if (sampleCnt < 1) {
        return nullptr;
    }
 
    const GrCaps* caps = this->caps();
 
    if (!caps->isFormatTexturable(backendTex.getBackendFormat(), backendTex.textureType()) ||
        !caps->isFormatRenderable(backendTex.getBackendFormat(), sampleCnt)) {
        return nullptr;
    }
 
    if (backendTex.width() > caps->maxRenderTargetSize() ||
        backendTex.height() > caps->maxRenderTargetSize()) {
        return nullptr;
    }
    sk_sp<GrTexture> tex =
            this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership, cacheable);
    SkASSERT(!tex || tex->asRenderTarget());
    if (tex && sampleCnt > 1 && !caps->msaaResolvesAutomatically()) {
        tex->asRenderTarget()->setRequiresManualMSAAResolve();
    }
    return tex;
}

wrapVulkanSecondaryCBAsRenderTarget()

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

Implements GrResourceProvider::wrapVulkanSecondaryCBAsRenderTarget

Definition at line 382 of file GrGpu.cpp.

                                                                                                 {
    return this->onWrapVulkanSecondaryCBAsRenderTarget(imageInfo, vkInfo);
}

writePixels() [1/2]

bool GrGpu::writePixels	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	srcColorType,
		const GrMipLevel	texels[],
		int	mipLevelCount,
		bool	prepForTexSampling = false
	)

Updates the pixels in a rectangle of a surface. No sRGB/linear conversions are performed.

Parameters

surface	the surface to write to.
rect	the rectangle of pixels to overwrite
surfaceColorType	the color type for this use of the surface.
srcColorType	the color type of the source buffer.
texels	array of mipmap levels containing texture data. Row bytes must be a multiple of srcColorType's bytes-per-pixel. Must be tight to level width if !caps->writePixelsRowBytesSupport().
mipLevelCount	number of levels in 'texels'
prepForTexSampling	After doing write pixels should the surface be prepared for texture sampling. This is currently only used by Vulkan for inline uploads to set that layout back to sampled after doing the upload. Inline uploads currently can happen between draws in a single op so it is not trivial to break up the OpsTask into two tasks when we see an inline upload. However, once we are able to support doing that we can remove this parameter.

Returns

true if the write succeeded, false if not. The read can fail because of the surface doesn't support writing (e.g. read only), the color type is not allowed for the format of the surface or if the rectangle written is not contained in the surface.

Definition at line 461 of file GrGpu.cpp.

                                                 {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    ATRACE_ANDROID_FRAMEWORK_ALWAYS("Texture upload(%u) %ix%i",
                                    surface->uniqueID().asUInt(), rect.width(), rect.height());
    SkASSERT(surface);
    SkASSERT(!surface->framebufferOnly());
 
    if (surface->readOnly()) {
        return false;
    }
 
    if (mipLevelCount == 0) {
        return false;
    } else if (mipLevelCount == 1) {
        // We require that if we are not mipped, then the write region is contained in the surface
        if (!SkIRect::MakeSize(surface->dimensions()).contains(rect)) {
            return false;
        }
    } else if (rect != SkIRect::MakeSize(surface->dimensions())) {
        // We require that if the texels are mipped, than the write region is the entire surface
        return false;
    }
 
    if (!validate_texel_levels(rect.size(), srcColorType, texels, mipLevelCount, this->caps())) {
        return false;
    }
 
    this->handleDirtyContext();
    if (!this->onWritePixels(surface,
                             rect,
                             surfaceColorType,
                             srcColorType,
                             texels,
                             mipLevelCount,
                             prepForTexSampling)) {
        return false;
    }
 
    this->didWriteToSurface(surface, kTopLeft_GrSurfaceOrigin, &rect, mipLevelCount);
    fStats.incTextureUploads();
 
    return true;
}

writePixels() [2/2]

bool GrGpu::writePixels ( GrSurface *  surface, SkIRect  rect, GrColorType  surfaceColorType, GrColorType  srcColorType, const void *  buffer, size_t  rowBytes, bool  prepForTexSampling = false  )

inline

Helper for the case of a single level.

Definition at line 293 of file GrGpu.h.

                                                      {
        GrMipLevel mipLevel = {buffer, rowBytes, nullptr};
        return this->writePixels(surface,
                                 rect,
                                 surfaceColorType,
                                 srcColorType,
                                 &mipLevel,
                                 1,
                                 prepForTexSampling);
    }

xferBarrier()

virtual void GrGpu::xferBarrier ( GrRenderTarget *  , GrXferBarrierType    )

pure virtual

Implemented in GrD3DGpu, and GrVkGpu.

Member Data Documentation

fStats

Stats GrGpu::fStats

protected

Definition at line 703 of file GrGpu.h.

---

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

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