#include <GrVkGpu.h>

Inheritance diagram for GrVkGpu:

Public Types
enum	PersistentCacheKeyType : uint32_t { kShader_PersistentCacheKeyType = 0 , kPipelineCache_PersistentCacheKeyType = 1 }

typedef void *	SubmitContext

typedef void(*	SubmitProc) (SubmitContext submitContext)

Public Types inherited from GrGpu
enum class	DisconnectType { kAbandon , kCleanup }

Public Member Functions
	~GrVkGpu () override

void	disconnect (DisconnectType) override

bool	disconnected () const

void	releaseUnlockedBackendObjects () override

GrThreadSafePipelineBuilder *	pipelineBuilder () override

sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder () override

const skgpu::VulkanInterface *	vkInterface () const

const GrVkCaps &	vkCaps () const

GrStagingBufferManager *	stagingBufferManager () override

void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >) override

bool	isDeviceLost () const override

skgpu::VulkanMemoryAllocator *	memoryAllocator () const

VkPhysicalDevice	physicalDevice () const

VkDevice	device () const

VkQueue	queue () const

uint32_t	queueIndex () const

GrVkCommandPool *	cmdPool () const

const VkPhysicalDeviceProperties &	physicalDeviceProperties () const

const VkPhysicalDeviceMemoryProperties &	physicalDeviceMemoryProperties () const

bool	protectedContext () const

GrVkResourceProvider &	resourceProvider ()

GrVkPrimaryCommandBuffer *	currentCommandBuffer () const

void	xferBarrier (GrRenderTarget *, GrXferBarrierType) override

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

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

void	deleteBackendTexture (const GrBackendTexture &) override

bool	compile (const GrProgramDesc &, const GrProgramInfo &) override

sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &, SkISize dimensions, int numStencilSamples) override

GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &) override

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

void	addBufferMemoryBarrier (const GrManagedResource , VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, VkBufferMemoryBarrier barrier) const

void	addBufferMemoryBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, VkBufferMemoryBarrier *barrier) const

void	addImageMemoryBarrier (const GrManagedResource , VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, VkImageMemoryBarrier barrier) const

bool	loadMSAAFromResolve (GrVkCommandBuffer commandBuffer, const GrVkRenderPass &renderPass, GrAttachment dst, GrVkImage *src, const SkIRect &srcRect)

bool	onRegenerateMipMapLevels (GrTexture *tex) override

void	onResolveRenderTarget (GrRenderTarget *target, const SkIRect &resolveRect) override

void	submitSecondaryCommandBuffer (std::unique_ptr< GrVkSecondaryCommandBuffer >)

void	submit (GrOpsRenderPass *) override

std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned) override

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

void	insertSemaphore (GrSemaphore *semaphore) override

void	waitSemaphore (GrSemaphore *semaphore) override

void	addDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler > drawable)

void	checkFinishProcs () override

void	finishOutstandingGpuWork () override

std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *) override

bool	updateBuffer (sk_sp< GrVkBuffer > buffer, const void *src, VkDeviceSize offset, VkDeviceSize size)

bool	zeroBuffer (sk_sp< GrGpuBuffer >)

void	storeVkPipelineCacheData () override

bool	beginRenderPass (const GrVkRenderPass , sk_sp< const GrVkFramebuffer >, const VkClearValue colorClear, const GrSurface *, const SkIRect &renderPassBounds, bool forSecondaryCB)

void	endRenderPass (GrRenderTarget *target, GrSurfaceOrigin origin, const SkIRect &bounds)

bool	checkVkResult (VkResult)

Public Member Functions inherited from GrGpu
	GrGpu (GrDirectContext *direct)

virtual	~GrGpu ()

GrDirectContext *	getContext ()

const GrDirectContext *	getContext () const

const GrCaps *	caps () const

sk_sp< const GrCaps >	refCaps () const

virtual GrRingBuffer *	uniformsRingBuffer ()

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)

bool	checkAndResetOOMed ()

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	precompileShader (const SkData &key, const SkData &data)

void	handleDirtyContext ()

Static Public Member Functions
static std::unique_ptr< GrGpu >	Make (const GrVkBackendContext &, const GrContextOptions &, GrDirectContext *)

Private Member Functions
GrBackendTexture	onCreateBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label) override

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

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

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

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

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

sk_sp< GrTexture >	onWrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType) override

sk_sp< GrTexture >	onWrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable) override

sk_sp< GrTexture >	onWrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable) override

sk_sp< GrRenderTarget >	onWrapBackendRenderTarget (const GrBackendRenderTarget &) override

sk_sp< GrRenderTarget >	onWrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &) override

sk_sp< GrGpuBuffer >	onCreateBuffer (size_t size, GrGpuBufferType type, GrAccessPattern) override

bool	onReadPixels (GrSurface , SkIRect, GrColorType surfaceColorType, GrColorType dstColorType, void buffer, size_t rowBytes) override

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

bool	onTransferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size) override

bool	onTransferPixelsTo (GrTexture *, SkIRect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset, size_t rowBytes) override

bool	onTransferPixelsFrom (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset) override

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

void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext) override

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

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

bool	onSubmitToGpu (GrSyncCpu sync) override

void	onReportSubmitHistograms () override

Additional Inherited Members
Protected Member Functions inherited from GrGpu
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 inherited from GrGpu
static bool	CompressedDataIsCorrect (SkISize dimensions, SkTextureCompressionType, skgpu::Mipmapped, const void *data, size_t length)

Protected Attributes inherited from GrGpu
Stats	fStats

Detailed Description

Definition at line 42 of file GrVkGpu.h.

Member Typedef Documentation

◆ SubmitContext

typedef void* GrVkGpu::SubmitContext

Definition at line 167 of file GrVkGpu.h.

◆ SubmitProc

typedef void(* GrVkGpu::SubmitProc) (SubmitContext submitContext)

Definition at line 168 of file GrVkGpu.h.

Member Enumeration Documentation

◆ PersistentCacheKeyType

enum GrVkGpu::PersistentCacheKeyType : uint32_t

Enumerator
kShader_PersistentCacheKeyType
kPipelineCache_PersistentCacheKeyType

Definition at line 184 of file GrVkGpu.h.

                                : uint32_t {
        kShader_PersistentCacheKeyType = 0,
        kPipelineCache_PersistentCacheKeyType = 1,
    };

Constructor & Destructor Documentation

◆ ~GrVkGpu()

GrVkGpu::~GrVkGpu ( )

override

Definition at line 292 of file GrVkGpu.cpp.

                  {
    if (!fDisconnected) {
        this->destroyResources();
    }
    // We don't delete the memory allocator until the very end of the GrVkGpu lifetime so that
    // clients can continue to delete backend textures even after a context has been abandoned.
    fMemoryAllocator.reset();
}

Member Function Documentation

◆ addBufferMemoryBarrier() [1/2]

void GrVkGpu::addBufferMemoryBarrier	(	const GrManagedResource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		VkBufferMemoryBarrier *	barrier
	)		const

Definition at line 2143 of file GrVkGpu.cpp.

                                                                           {
    if (!this->currentCommandBuffer()) {
        return;
    }
    SkASSERT(resource);
    this->currentCommandBuffer()->pipelineBarrier(this,
                                                  resource,
                                                  srcStageMask,
                                                  dstStageMask,
                                                  byRegion,
                                                  GrVkCommandBuffer::kBufferMemory_BarrierType,
                                                  barrier);
}

◆ addBufferMemoryBarrier() [2/2]

void GrVkGpu::addBufferMemoryBarrier	(	VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		VkBufferMemoryBarrier *	barrier
	)		const

Definition at line 2160 of file GrVkGpu.cpp.

                                                                           {
    if (!this->currentCommandBuffer()) {
        return;
    }
    // We don't pass in a resource here to the command buffer. The command buffer only is using it
    // to hold a ref, but every place where we add a buffer memory barrier we are doing some other
    // command with the buffer on the command buffer. Thus those other commands will already cause
    // the command buffer to be holding a ref to the buffer.
    this->currentCommandBuffer()->pipelineBarrier(this,
                                                  /*resource=*/nullptr,
                                                  srcStageMask,
                                                  dstStageMask,
                                                  byRegion,
                                                  GrVkCommandBuffer::kBufferMemory_BarrierType,
                                                  barrier);
}

◆ addDrawable()

void GrVkGpu::addDrawable ( std::unique_ptr< SkDrawable::GpuDrawHandler > drawable )

Definition at line 2769 of file GrVkGpu.cpp.

                                                                          {
    fDrawables.emplace_back(std::move(drawable));
}

◆ addFinishedProc()

void GrVkGpu::addFinishedProc	(	GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 2240 of file GrVkGpu.cpp.

                                                                    {
    SkASSERT(finishedProc);
    this->addFinishedCallback(skgpu::RefCntedCallback::Make(finishedProc, finishedContext));
}

◆ addImageMemoryBarrier()

void GrVkGpu::addImageMemoryBarrier	(	const GrManagedResource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		VkImageMemoryBarrier *	barrier
	)		const

Definition at line 2180 of file GrVkGpu.cpp.

                                                                         {
    // If we are in the middle of destroying or abandoning the context we may hit a release proc
    // that triggers the destruction of a GrVkImage. This could cause us to try and transfer the
    // VkImage back to the original queue. In this state we don't submit anymore work and we may not
    // have a current command buffer. Thus we won't do the queue transfer.
    if (!this->currentCommandBuffer()) {
        return;
    }
    SkASSERT(resource);
    this->currentCommandBuffer()->pipelineBarrier(this,
                                                  resource,
                                                  srcStageMask,
                                                  dstStageMask,
                                                  byRegion,
                                                  GrVkCommandBuffer::kImageMemory_BarrierType,
                                                  barrier);
}

◆ beginRenderPass()

bool GrVkGpu::beginRenderPass	(	const GrVkRenderPass *	renderPass,
		sk_sp< const GrVkFramebuffer >	framebuffer,
		const VkClearValue *	colorClear,
		const GrSurface *	target,
		const SkIRect &	renderPassBounds,
		bool	forSecondaryCB
	)

Definition at line 2637 of file GrVkGpu.cpp.

                                                   {
    if (!this->currentCommandBuffer()) {
        return false;
    }
    SkASSERT (!framebuffer->isExternal());
 
#ifdef SK_DEBUG
    uint32_t index;
    bool result = renderPass->colorAttachmentIndex(&index);
    SkASSERT(result && 0 == index);
    result = renderPass->stencilAttachmentIndex(&index);
    if (result) {
        SkASSERT(1 == index);
    }
#endif
    VkClearValue clears[3];
    int stencilIndex = renderPass->hasResolveAttachment() ? 2 : 1;
    clears[0].color = colorClear->color;
    clears[stencilIndex].depthStencil.depth = 0.0f;
    clears[stencilIndex].depthStencil.stencil = 0;
 
   return this->currentCommandBuffer()->beginRenderPass(
        this, renderPass, std::move(framebuffer), clears, target, renderPassBounds, forSecondaryCB);
}

◆ checkFinishProcs()

void GrVkGpu::checkFinishProcs ( )

inlineoverridevirtual

Implements GrGpu.

Definition at line 174 of file GrVkGpu.h.

174{ fResourceProvider.checkCommandBuffers(); }

GrVkResourceProvider::checkCommandBuffers

void checkCommandBuffers()

Definition GrVkResourceProvider.cpp:428

◆ checkVkResult()

bool GrVkGpu::checkVkResult ( VkResult result )

Definition at line 2675 of file GrVkGpu.cpp.

                                           {
    switch (result) {
        case VK_SUCCESS:
            return true;
        case VK_ERROR_DEVICE_LOST:
            if (!fDeviceIsLost) {
                // Callback should only be invoked once, and device should be marked as lost first.
                fDeviceIsLost = true;
                skgpu::InvokeDeviceLostCallback(vkInterface(),
                                                device(),
                                                fDeviceLostContext,
                                                fDeviceLostProc,
                                                vkCaps().supportsDeviceFaultInfo());
            }
            return false;
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            this->setOOMed();
            return false;
        default:
            return false;
    }
}

◆ cmdPool()

GrVkCommandPool * GrVkGpu::cmdPool ( ) const

inline

Definition at line 74 of file GrVkGpu.h.

74{ return fMainCmdPool; }

◆ compile()

bool GrVkGpu::compile	(	const GrProgramDesc &	,
		const GrProgramInfo &
	)

overridevirtual

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

Implements GrGpu.

Definition at line 2042 of file GrVkGpu.cpp.

                                                                                 {
    GrVkRenderPass::AttachmentsDescriptor attachmentsDescriptor;
    GrVkRenderPass::AttachmentFlags attachmentFlags;
    GrVkRenderTarget::ReconstructAttachmentsDescriptor(this->vkCaps(), programInfo,
                                                       &attachmentsDescriptor, &attachmentFlags);
 
    GrVkRenderPass::SelfDependencyFlags selfDepFlags = GrVkRenderPass::SelfDependencyFlags::kNone;
    if (programInfo.renderPassBarriers() & GrXferBarrierFlags::kBlend) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForNonCoherentAdvBlend;
    }
    if (programInfo.renderPassBarriers() & GrXferBarrierFlags::kTexture) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForInputAttachment;
    }
 
    GrVkRenderPass::LoadFromResolve loadFromResolve = GrVkRenderPass::LoadFromResolve::kNo;
    if (this->vkCaps().programInfoWillUseDiscardableMSAA(programInfo) &&
        programInfo.colorLoadOp() == GrLoadOp::kLoad) {
        loadFromResolve = GrVkRenderPass::LoadFromResolve::kLoad;
    }
    sk_sp<const GrVkRenderPass> renderPass(this->resourceProvider().findCompatibleRenderPass(
            &attachmentsDescriptor, attachmentFlags, selfDepFlags, loadFromResolve));
    if (!renderPass) {
        return false;
    }
 
    GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
 
    auto pipelineState = this->resourceProvider().findOrCreateCompatiblePipelineState(
                                    desc,
                                    programInfo,
                                    renderPass->vkRenderPass(),
                                    &stat);
    if (!pipelineState) {
        return false;
    }
 
    return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
}

◆ currentCommandBuffer()

GrVkPrimaryCommandBuffer * GrVkGpu::currentCommandBuffer ( ) const

inline

Definition at line 85 of file GrVkGpu.h.

85{ return fMainCmdBuffer; }

◆ deleteBackendTexture()

void GrVkGpu::deleteBackendTexture ( const GrBackendTexture & )

overridevirtual

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.

Implements GrGpu.

Definition at line 2033 of file GrVkGpu.cpp.

                                                              {
    SkASSERT(GrBackendApi::kVulkan == tex.fBackend);
 
    GrVkImageInfo info;
    if (GrBackendTextures::GetVkImageInfo(tex, &info)) {
        GrVkImage::DestroyImageInfo(this, const_cast<GrVkImageInfo*>(&info));
    }
}

◆ device()

VkDevice GrVkGpu::device ( ) const

inline

Definition at line 71 of file GrVkGpu.h.

71{ return fDevice; }

◆ disconnect()

void GrVkGpu::disconnect ( DisconnectType type )

overridevirtual

Reimplemented from GrGpu.

Definition at line 302 of file GrVkGpu.cpp.

                                            {
    INHERITED::disconnect(type);
    if (!fDisconnected) {
        this->destroyResources();
 
        fSemaphoresToWaitOn.clear();
        fSemaphoresToSignal.clear();
        fMainCmdBuffer = nullptr;
        fDisconnected = true;
    }
}

◆ disconnected()

bool GrVkGpu::disconnected ( ) const

inline

Definition at line 51 of file GrVkGpu.h.

51{ return fDisconnected; }

◆ endRenderPass()

void GrVkGpu::endRenderPass	(	GrRenderTarget *	target,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds
	)

Definition at line 2667 of file GrVkGpu.cpp.

                                                   {
    // We had a command buffer when we started the render pass, we should have one now as well.
    SkASSERT(this->currentCommandBuffer());
    this->currentCommandBuffer()->endRenderPass(this);
    this->didWriteToSurface(target, origin, &bounds);
}

◆ finishOutstandingGpuWork()

void GrVkGpu::finishOutstandingGpuWork ( )

overridevirtual

Implements GrGpu.

Definition at line 2263 of file GrVkGpu.cpp.

                                       {
    VK_CALL(QueueWaitIdle(fQueue));
 
    if (this->vkCaps().mustSyncCommandBuffersWithQueue()) {
        fResourceProvider.forceSyncAllCommandBuffers();
    }
}

◆ getPreferredStencilFormat()

GrBackendFormat GrVkGpu::getPreferredStencilFormat ( const GrBackendFormat & )

inlineoverridevirtual

Implements GrGpu.

Definition at line 120 of file GrVkGpu.h.

                                                                               {
        return GrBackendFormats::MakeVk(this->vkCaps().preferredStencilFormat());
    }

◆ insertSemaphore()

void GrVkGpu::insertSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 2724 of file GrVkGpu.cpp.

                                                    {
    SkASSERT(semaphore);
 
    GrVkSemaphore* vkSem = static_cast<GrVkSemaphore*>(semaphore);
 
    GrVkSemaphore::Resource* resource = vkSem->getResource();
    if (resource->shouldSignal()) {
        resource->ref();
        fSemaphoresToSignal.push_back(resource);
    }
}

◆ isDeviceLost()

bool GrVkGpu::isDeviceLost ( ) const

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 66 of file GrVkGpu.h.

66{ return fDeviceIsLost; }

◆ loadMSAAFromResolve()

bool GrVkGpu::loadMSAAFromResolve	(	GrVkCommandBuffer *	commandBuffer,
		const GrVkRenderPass &	renderPass,
		GrAttachment *	dst,
		GrVkImage *	src,
		const SkIRect &	srcRect
	)

Definition at line 1516 of file GrVkGpu.cpp.

                                                          {
    return fMSAALoadManager.loadMSAAFromResolve(this, commandBuffer, renderPass, dst, src, srcRect);
}

◆ Make()

std::unique_ptr< GrGpu > GrVkGpu::Make	(	const GrVkBackendContext &	backendContext,
		const GrContextOptions &	options,
		GrDirectContext *	direct
	)

static

Definition at line 66 of file GrVkGpu.cpp.

                                                              {
    if (backendContext.fInstance == VK_NULL_HANDLE ||
        backendContext.fPhysicalDevice == VK_NULL_HANDLE ||
        backendContext.fDevice == VK_NULL_HANDLE ||
        backendContext.fQueue == VK_NULL_HANDLE) {
        return nullptr;
    }
    if (!backendContext.fGetProc) {
        return nullptr;
    }
 
    PFN_vkEnumerateInstanceVersion localEnumerateInstanceVersion =
            reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
                    backendContext.fGetProc("vkEnumerateInstanceVersion",
                                            VK_NULL_HANDLE, VK_NULL_HANDLE));
    uint32_t instanceVersion = 0;
    if (!localEnumerateInstanceVersion) {
        instanceVersion = VK_MAKE_VERSION(1, 0, 0);
    } else {
        VkResult err = localEnumerateInstanceVersion(&instanceVersion);
        if (err) {
            SkDebugf("Failed to enumerate instance version. Err: %d\n", err);
            return nullptr;
        }
    }
 
    PFN_vkGetPhysicalDeviceProperties localGetPhysicalDeviceProperties =
            reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
                    backendContext.fGetProc("vkGetPhysicalDeviceProperties",
                                            backendContext.fInstance,
                                            VK_NULL_HANDLE));
 
    if (!localGetPhysicalDeviceProperties) {
        return nullptr;
    }
    VkPhysicalDeviceProperties physDeviceProperties;
    localGetPhysicalDeviceProperties(backendContext.fPhysicalDevice, &physDeviceProperties);
    uint32_t physDevVersion = physDeviceProperties.apiVersion;
 
    uint32_t apiVersion = backendContext.fMaxAPIVersion ? backendContext.fMaxAPIVersion
                                                        : instanceVersion;
 
    instanceVersion = std::min(instanceVersion, apiVersion);
    physDevVersion = std::min(physDevVersion, apiVersion);
 
    sk_sp<const skgpu::VulkanInterface> interface;
 
    if (backendContext.fVkExtensions) {
        interface.reset(new skgpu::VulkanInterface(backendContext.fGetProc,
                                                   backendContext.fInstance,
                                                   backendContext.fDevice,
                                                   instanceVersion,
                                                   physDevVersion,
                                                   backendContext.fVkExtensions));
        if (!interface->validate(instanceVersion, physDevVersion, backendContext.fVkExtensions)) {
            return nullptr;
        }
    } else {
        skgpu::VulkanExtensions extensions;
        // The only extension flag that may effect the vulkan backend is the swapchain extension. We
        // need to know if this is enabled to know if we can transition to a present layout when
        // flushing a surface.
        if (backendContext.fExtensions & kKHR_swapchain_GrVkExtensionFlag) {
            const char* swapChainExtName = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
            extensions.init(backendContext.fGetProc, backendContext.fInstance,
                            backendContext.fPhysicalDevice, 0, nullptr, 1, &swapChainExtName);
        }
        interface.reset(new skgpu::VulkanInterface(backendContext.fGetProc,
                                                   backendContext.fInstance,
                                                   backendContext.fDevice,
                                                   instanceVersion,
                                                   physDevVersion,
                                                   &extensions));
        if (!interface->validate(instanceVersion, physDevVersion, &extensions)) {
            return nullptr;
        }
    }
 
    sk_sp<GrVkCaps> caps;
    if (backendContext.fDeviceFeatures2) {
        caps.reset(new GrVkCaps(options, interface.get(), backendContext.fPhysicalDevice,
                                *backendContext.fDeviceFeatures2, instanceVersion, physDevVersion,
                                *backendContext.fVkExtensions, backendContext.fProtectedContext));
    } else if (backendContext.fDeviceFeatures) {
        VkPhysicalDeviceFeatures2 features2;
        features2.pNext = nullptr;
        features2.features = *backendContext.fDeviceFeatures;
        caps.reset(new GrVkCaps(options, interface.get(), backendContext.fPhysicalDevice,
                                features2, instanceVersion, physDevVersion,
                                *backendContext.fVkExtensions, backendContext.fProtectedContext));
    } else {
        VkPhysicalDeviceFeatures2 features;
        memset(&features, 0, sizeof(VkPhysicalDeviceFeatures2));
        features.pNext = nullptr;
        if (backendContext.fFeatures & kGeometryShader_GrVkFeatureFlag) {
            features.features.geometryShader = true;
        }
        if (backendContext.fFeatures & kDualSrcBlend_GrVkFeatureFlag) {
            features.features.dualSrcBlend = true;
        }
        if (backendContext.fFeatures & kSampleRateShading_GrVkFeatureFlag) {
            features.features.sampleRateShading = true;
        }
        skgpu::VulkanExtensions extensions;
        // The only extension flag that may effect the vulkan backend is the swapchain extension. We
        // need to know if this is enabled to know if we can transition to a present layout when
        // flushing a surface.
        if (backendContext.fExtensions & kKHR_swapchain_GrVkExtensionFlag) {
            const char* swapChainExtName = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
            extensions.init(backendContext.fGetProc, backendContext.fInstance,
                            backendContext.fPhysicalDevice, 0, nullptr, 1, &swapChainExtName);
        }
        caps.reset(new GrVkCaps(options, interface.get(), backendContext.fPhysicalDevice,
                                features, instanceVersion, physDevVersion, extensions,
                                backendContext.fProtectedContext));
    }
 
    if (!caps) {
        return nullptr;
    }
 
    sk_sp<skgpu::VulkanMemoryAllocator> memoryAllocator = backendContext.fMemoryAllocator;
    if (!memoryAllocator) {
        // We were not given a memory allocator at creation
        memoryAllocator = skgpu::VulkanAMDMemoryAllocator::Make(backendContext.fInstance,
                                                                backendContext.fPhysicalDevice,
                                                                backendContext.fDevice,
                                                                physDevVersion,
                                                                backendContext.fVkExtensions,
                                                                interface.get(),
                                                                /*=threadSafe=*/false);
    }
    if (!memoryAllocator) {
        SkDEBUGFAIL("No supplied vulkan memory allocator and unable to create one internally.");
        return nullptr;
    }
 
    std::unique_ptr<GrVkGpu> vkGpu(new GrVkGpu(direct,
                                               backendContext,
                                               std::move(caps),
                                               interface,
                                               instanceVersion,
                                               physDevVersion,
                                               std::move(memoryAllocator)));
    if (backendContext.fProtectedContext == GrProtected::kYes &&
        !vkGpu->vkCaps().supportsProtectedContent()) {
        return nullptr;
    }
    return vkGpu;
}

◆ makeMSAAAttachment()

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

overridevirtual

Implements GrGpu.

Definition at line 1625 of file GrVkGpu.cpp.

                                                                         {
    VkFormat pixelFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &pixelFormat));
    SkASSERT(!skgpu::VkFormatIsCompressed(pixelFormat));
    SkASSERT(this->vkCaps().isFormatRenderable(pixelFormat, numSamples));
 
    fStats.incMSAAAttachmentCreates();
    return GrVkImage::MakeMSAA(this, dimensions, numSamples, pixelFormat, isProtected, memoryless);
}

◆ makeSemaphore()

std::unique_ptr< GrSemaphore > GrVkGpu::makeSemaphore ( bool isOwned )

overridevirtual

Implements GrGpu.

Definition at line 2713 of file GrVkGpu.cpp.

                                                                            {
    return GrVkSemaphore::Make(this, isOwned);
}

◆ makeStencilAttachment()

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

overridevirtual

Implements GrGpu.

Definition at line 1617 of file GrVkGpu.cpp.

                                                                                              {
    VkFormat sFmt = this->vkCaps().preferredStencilFormat();
 
    fStats.incStencilAttachmentCreates();
    return GrVkImage::MakeStencil(this, dimensions, numStencilSamples, sFmt);
}

◆ memoryAllocator()

skgpu::VulkanMemoryAllocator * GrVkGpu::memoryAllocator ( ) const

inline

Definition at line 68 of file GrVkGpu.h.

68{ return fMemoryAllocator.get(); }

◆ onClearBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1730 of file GrVkGpu.cpp.

                                                              {
    GrVkImageInfo info;
    SkAssertResult(GrBackendTextures::GetVkImageInfo(backendTexture, &info));
 
    sk_sp<skgpu::MutableTextureState> mutableState = backendTexture.getMutableState();
    SkASSERT(mutableState);
    sk_sp<GrVkTexture> texture =
                GrVkTexture::MakeWrappedTexture(this, backendTexture.dimensions(),
                                                kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
                                                kRW_GrIOType, info, std::move(mutableState));
    if (!texture) {
        return false;
    }
    GrVkImage* texImage = texture->textureImage();
 
    GrVkPrimaryCommandBuffer* cmdBuffer = this->currentCommandBuffer();
    if (!cmdBuffer) {
        return false;
    }
 
    texImage->setImageLayout(this,
                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                             VK_ACCESS_TRANSFER_WRITE_BIT,
                             VK_PIPELINE_STAGE_TRANSFER_BIT,
                             false);
 
    // CmdClearColorImage doesn't work for compressed formats
    SkASSERT(!skgpu::VkFormatIsCompressed(info.fFormat));
 
    VkClearColorValue vkColor;
    // If we ever support SINT or UINT formats this needs to be updated to use the int32 and
    // uint32 union members in those cases.
    vkColor.float32[0] = color[0];
    vkColor.float32[1] = color[1];
    vkColor.float32[2] = color[2];
    vkColor.float32[3] = color[3];
    VkImageSubresourceRange range;
    range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    range.baseArrayLayer = 0;
    range.baseMipLevel = 0;
    range.layerCount = 1;
    range.levelCount = info.fLevelCount;
    cmdBuffer->clearColorImage(this, texImage, &vkColor, 1, &range);
 
    // Change image layout to shader read since if we use this texture as a borrowed
    // texture within Ganesh we require that its layout be set to that
    texImage->setImageLayout(this, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                  VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                                  false);
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
    return true;
}

◆ onCopySurface()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 2433 of file GrVkGpu.cpp.

                                                         {
#ifdef SK_DEBUG
    if (GrVkRenderTarget* srcRT = static_cast<GrVkRenderTarget*>(src->asRenderTarget())) {
        SkASSERT(!srcRT->wrapsSecondaryCommandBuffer());
    }
    if (GrVkRenderTarget* dstRT = static_cast<GrVkRenderTarget*>(dst->asRenderTarget())) {
        SkASSERT(!dstRT->wrapsSecondaryCommandBuffer());
    }
#endif
    if (src->isProtected() && !dst->isProtected()) {
        SkDebugf("Can't copy from protected memory to non-protected");
        return false;
    }
 
    GrVkImage* dstImage;
    GrVkImage* srcImage;
    GrRenderTarget* dstRT = dst->asRenderTarget();
    if (dstRT) {
        GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(dstRT);
        if (vkRT->wrapsSecondaryCommandBuffer()) {
            return false;
        }
        // This will technically return true for single sample rts that used DMSAA in which case we
        // don't have to pick the resolve attachment. But in that case the resolve and color
        // attachments will be the same anyways.
        if (this->vkCaps().renderTargetSupportsDiscardableMSAA(vkRT)) {
            dstImage = vkRT->resolveAttachment();
        } else {
            dstImage = vkRT->colorAttachment();
        }
    } else if (dst->asTexture()) {
        dstImage = static_cast<GrVkTexture*>(dst->asTexture())->textureImage();
    } else {
        // The surface in a GrAttachment already
        dstImage = static_cast<GrVkImage*>(dst);
    }
    GrRenderTarget* srcRT = src->asRenderTarget();
    if (srcRT) {
        GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(srcRT);
        // This will technically return true for single sample rts that used DMSAA in which case we
        // don't have to pick the resolve attachment. But in that case the resolve and color
        // attachments will be the same anyways.
        if (this->vkCaps().renderTargetSupportsDiscardableMSAA(vkRT)) {
            srcImage = vkRT->resolveAttachment();
        } else {
            srcImage = vkRT->colorAttachment();
        }
    } else if (src->asTexture()) {
        SkASSERT(src->asTexture());
        srcImage = static_cast<GrVkTexture*>(src->asTexture())->textureImage();
    } else {
        // The surface in a GrAttachment already
        srcImage = static_cast<GrVkImage*>(src);
    }
 
    VkFormat dstFormat = dstImage->imageFormat();
    VkFormat srcFormat = srcImage->imageFormat();
 
    int dstSampleCnt = dstImage->numSamples();
    int srcSampleCnt = srcImage->numSamples();
 
    bool dstHasYcbcr = dstImage->ycbcrConversionInfo().isValid();
    bool srcHasYcbcr = srcImage->ycbcrConversionInfo().isValid();
 
    if (srcRect.size() == dstRect.size()) {
        // Prefer resolves or copy-image commands when there is no scaling
        const SkIPoint dstPoint = dstRect.topLeft();
        if (this->vkCaps().canCopyAsResolve(dstFormat, dstSampleCnt, dstHasYcbcr,
                                            srcFormat, srcSampleCnt, srcHasYcbcr)) {
            this->copySurfaceAsResolve(dst, src, srcRect, dstPoint);
            return true;
        }
 
        if (this->vkCaps().canCopyImage(dstFormat, dstSampleCnt, dstHasYcbcr,
                                        srcFormat, srcSampleCnt, srcHasYcbcr)) {
            this->copySurfaceAsCopyImage(dst, src, dstImage, srcImage, srcRect, dstPoint);
            return true;
        }
    }
 
    if (this->vkCaps().canCopyAsBlit(dstFormat,
                                     dstSampleCnt,
                                     dstImage->isLinearTiled(),
                                     dstHasYcbcr,
                                     srcFormat,
                                     srcSampleCnt,
                                     srcImage->isLinearTiled(),
                                     srcHasYcbcr)) {
        this->copySurfaceAsBlit(dst, src, dstImage, srcImage, srcRect, dstRect, filter);
        return true;
    }
 
    return false;
}

◆ onCreateBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1788 of file GrVkGpu.cpp.

                                                                       {
    const GrVkCaps& caps = this->vkCaps();
 
    if (fProtectedContext != isProtected) {
        return {};
    }
 
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return {};
    }
 
    // TODO: move the texturability check up to GrGpu::createBackendTexture and just assert here
    if (!caps.isVkFormatTexturable(vkFormat)) {
        return {};
    }
 
    if (skgpu::VkFormatNeedsYcbcrSampler(vkFormat)) {
        return {};
    }
 
    GrVkImageInfo info;
    if (!this->createVkImageForBackendSurface(vkFormat, dimensions, 1, GrTexturable::kYes,
                                              renderable, mipmapped, &info, isProtected)) {
        return {};
    }
 
    return GrBackendTextures::MakeVk(dimensions.width(), dimensions.height(), info);
}

◆ onCreateBuffer()

sk_sp< GrGpuBuffer > GrVkGpu::onCreateBuffer	(	size_t	size,
		GrGpuBufferType	type,
		GrAccessPattern	accessPattern
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 468 of file GrVkGpu.cpp.

                                                                          {
#ifdef SK_DEBUG
    switch (type) {
        case GrGpuBufferType::kVertex:
        case GrGpuBufferType::kIndex:
        case GrGpuBufferType::kDrawIndirect:
            SkASSERT(accessPattern == kDynamic_GrAccessPattern ||
                     accessPattern == kStatic_GrAccessPattern);
            break;
        case GrGpuBufferType::kXferCpuToGpu:
            SkASSERT(accessPattern == kDynamic_GrAccessPattern);
            break;
        case GrGpuBufferType::kXferGpuToCpu:
            SkASSERT(accessPattern == kDynamic_GrAccessPattern ||
                     accessPattern == kStream_GrAccessPattern);
            break;
        case GrGpuBufferType::kUniform:
            SkASSERT(accessPattern == kDynamic_GrAccessPattern);
            break;
    }
#endif
    return GrVkBuffer::Make(this, size, type, accessPattern);
}

◆ onCreateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1823 of file GrVkGpu.cpp.

                                                                                    {
    return this->onCreateBackendTexture(dimensions,
                                        format,
                                        GrRenderable::kNo,
                                        mipmapped,
                                        isProtected,
                                        /*label=*/"VkGpu_CreateCompressedBackendTexture");
}

◆ onCreateCompressedTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1202 of file GrVkGpu.cpp.

                                                                     {
    VkFormat pixelFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &pixelFormat));
    SkASSERT(skgpu::VkFormatIsCompressed(pixelFormat));
 
    int numMipLevels = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height())+1;
    }
 
    GrMipmapStatus mipmapStatus = (mipmapped == skgpu::Mipmapped::kYes)
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
 
    auto tex = GrVkTexture::MakeNewTexture(this,
                                           budgeted,
                                           dimensions,
                                           pixelFormat,
                                           numMipLevels,
                                           isProtected,
                                           mipmapStatus,
                                           /*label=*/"VkGpu_CreateCompressedTexture");
    if (!tex) {
        return nullptr;
    }
 
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(format);
    if (!this->uploadTexDataCompressed(tex->textureImage(), compression, pixelFormat,
                                       dimensions, mipmapped, data, dataSize)) {
        return nullptr;
    }
 
    return tex;
}

◆ onCreateTexture()

sk_sp< GrTexture > GrVkGpu::onCreateTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrRenderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		int	mipLevelCount,
		uint32_t	levelClearMask,
		std::string_view	label
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1137 of file GrVkGpu.cpp.

                                                                {
    VkFormat pixelFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &pixelFormat));
    SkASSERT(!skgpu::VkFormatIsCompressed(pixelFormat));
    SkASSERT(mipLevelCount > 0);
 
    GrMipmapStatus mipmapStatus =
            mipLevelCount > 1 ? GrMipmapStatus::kDirty : GrMipmapStatus::kNotAllocated;
 
    sk_sp<GrVkTexture> tex;
    if (renderable == GrRenderable::kYes) {
        tex = GrVkTextureRenderTarget::MakeNewTextureRenderTarget(
                this, budgeted, dimensions, pixelFormat, mipLevelCount, renderTargetSampleCnt,
                mipmapStatus, isProtected, label);
    } else {
        tex = GrVkTexture::MakeNewTexture(this, budgeted, dimensions, pixelFormat,
                                          mipLevelCount, isProtected, mipmapStatus, label);
    }
 
    if (!tex) {
        return nullptr;
    }
 
    if (levelClearMask) {
        if (!this->currentCommandBuffer()) {
            return nullptr;
        }
        STArray<1, VkImageSubresourceRange> ranges;
        bool inRange = false;
        GrVkImage* texImage = tex->textureImage();
        for (uint32_t i = 0; i < texImage->mipLevels(); ++i) {
            if (levelClearMask & (1U << i)) {
                if (inRange) {
                    ranges.back().levelCount++;
                } else {
                    auto& range = ranges.push_back();
                    range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    range.baseArrayLayer = 0;
                    range.baseMipLevel = i;
                    range.layerCount = 1;
                    range.levelCount = 1;
                    inRange = true;
                }
            } else if (inRange) {
                inRange = false;
            }
        }
        SkASSERT(!ranges.empty());
        static constexpr VkClearColorValue kZeroClearColor = {};
        texImage->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                            VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
        this->currentCommandBuffer()->clearColorImage(this, texImage, &kZeroClearColor,
                                                      ranges.size(), ranges.begin());
    }
    return tex;
}

◆ onGetOpsRenderPass()

GrOpsRenderPass * GrVkGpu::onGetOpsRenderPass	(	GrRenderTarget *	rt,
		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
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 324 of file GrVkGpu.cpp.

                                                   {
    if (!fCachedOpsRenderPass) {
        fCachedOpsRenderPass = std::make_unique<GrVkOpsRenderPass>(this);
    }
 
    // For the given render target and requested render pass features we need to find a compatible
    // framebuffer to use for the render pass. Technically it is the underlying VkRenderPass that
    // is compatible, but that is part of the framebuffer that we get here.
    GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
 
    SkASSERT(!useMSAASurface ||
             rt->numSamples() > 1 ||
             (this->vkCaps().supportsDiscardableMSAAForDMSAA() &&
              vkRT->resolveAttachment() &&
              vkRT->resolveAttachment()->supportsInputAttachmentUsage()));
 
    // Covert the GrXferBarrierFlags into render pass self dependency flags
    GrVkRenderPass::SelfDependencyFlags selfDepFlags = GrVkRenderPass::SelfDependencyFlags::kNone;
    if (renderPassXferBarriers & GrXferBarrierFlags::kBlend) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForNonCoherentAdvBlend;
    }
    if (renderPassXferBarriers & GrXferBarrierFlags::kTexture) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForInputAttachment;
    }
 
    // Figure out if we need a resolve attachment for this render pass. A resolve attachment is
    // needed if we are using msaa to draw with a discardable msaa attachment. If we are in this
    // case we also need to update the color load/store ops since we don't want to ever load or
    // store the msaa color attachment, but may need to for the resolve attachment.
    GrOpsRenderPass::LoadAndStoreInfo localColorInfo = colorInfo;
    bool withResolve = false;
    GrVkRenderPass::LoadFromResolve loadFromResolve = GrVkRenderPass::LoadFromResolve::kNo;
    GrOpsRenderPass::LoadAndStoreInfo resolveInfo{GrLoadOp::kLoad, GrStoreOp::kStore, {}};
    if (useMSAASurface && this->vkCaps().renderTargetSupportsDiscardableMSAA(vkRT)) {
        withResolve = true;
        localColorInfo.fStoreOp = GrStoreOp::kDiscard;
        if (colorInfo.fLoadOp == GrLoadOp::kLoad) {
            loadFromResolve = GrVkRenderPass::LoadFromResolve::kLoad;
            localColorInfo.fLoadOp = GrLoadOp::kDiscard;
        } else {
            resolveInfo.fLoadOp = GrLoadOp::kDiscard;
        }
    }
 
    // Get the framebuffer to use for the render pass
   sk_sp<GrVkFramebuffer> framebuffer;
    if (vkRT->wrapsSecondaryCommandBuffer()) {
        framebuffer = vkRT->externalFramebuffer();
    } else {
        auto fb = vkRT->getFramebuffer(withResolve, SkToBool(stencil), selfDepFlags,
                                       loadFromResolve);
        framebuffer = sk_ref_sp(fb);
    }
    if (!framebuffer) {
        return nullptr;
    }
 
    if (!fCachedOpsRenderPass->set(rt, std::move(framebuffer), origin, bounds, localColorInfo,
                                   stencilInfo, resolveInfo, selfDepFlags, loadFromResolve,
                                   sampledProxies)) {
        return nullptr;
    }
    return fCachedOpsRenderPass.get();
}

◆ onReadPixels()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 2530 of file GrVkGpu.cpp.

                                            {
    if (surface->isProtected()) {
        return false;
    }
 
    if (!this->currentCommandBuffer()) {
        return false;
    }
 
    GrVkImage* image = nullptr;
    GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(surface->asRenderTarget());
    if (rt) {
        // Reading from render targets that wrap a secondary command buffer is not allowed since
        // it would require us to know the VkImage, which we don't have, as well as need us to
        // stop and start the VkRenderPass which we don't have access to.
        if (rt->wrapsSecondaryCommandBuffer()) {
            return false;
        }
        image = rt->nonMSAAAttachment();
    } else {
        image = static_cast<GrVkTexture*>(surface->asTexture())->textureImage();
    }
 
    if (!image) {
        return false;
    }
 
    if (dstColorType == GrColorType::kUnknown ||
        dstColorType != this->vkCaps().transferColorType(image->imageFormat(), surfaceColorType)) {
        return false;
    }
 
    // Change layout of our target so it can be used as copy
    image->setImageLayout(this,
                          VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                          VK_ACCESS_TRANSFER_READ_BIT,
                          VK_PIPELINE_STAGE_TRANSFER_BIT,
                          false);
 
    size_t bpp = GrColorTypeBytesPerPixel(dstColorType);
    if (skgpu::VkFormatBytesPerBlock(image->imageFormat()) != bpp) {
        return false;
    }
    size_t tightRowBytes = bpp*rect.width();
 
    VkBufferImageCopy region;
    memset(&region, 0, sizeof(VkBufferImageCopy));
    VkOffset3D offset = { rect.left(), rect.top(), 0 };
    region.imageOffset = offset;
    region.imageExtent = { (uint32_t)rect.width(), (uint32_t)rect.height(), 1 };
 
    size_t transBufferRowBytes = bpp * region.imageExtent.width;
    size_t imageRows = region.imageExtent.height;
    GrResourceProvider* resourceProvider = this->getContext()->priv().resourceProvider();
    sk_sp<GrGpuBuffer> transferBuffer = resourceProvider->createBuffer(
            transBufferRowBytes * imageRows,
            GrGpuBufferType::kXferGpuToCpu,
            kDynamic_GrAccessPattern,
            GrResourceProvider::ZeroInit::kNo);
 
    if (!transferBuffer) {
        return false;
    }
 
    GrVkBuffer* vkBuffer = static_cast<GrVkBuffer*>(transferBuffer.get());
 
    // Copy the image to a buffer so we can map it to cpu memory
    region.bufferOffset = 0;
    region.bufferRowLength = 0; // Forces RowLength to be width. We handle the rowBytes below.
    region.bufferImageHeight = 0; // Forces height to be tightly packed. Only useful for 3d images.
    region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
 
    this->currentCommandBuffer()->copyImageToBuffer(this,
                                                    image,
                                                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                                    transferBuffer,
                                                    1,
                                                    &region);
 
    // make sure the copy to buffer has finished
    vkBuffer->addMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT,
                               VK_ACCESS_HOST_READ_BIT,
                               VK_PIPELINE_STAGE_TRANSFER_BIT,
                               VK_PIPELINE_STAGE_HOST_BIT,
                               false);
 
    // We need to submit the current command buffer to the Queue and make sure it finishes before
    // we can copy the data out of the buffer.
    if (!this->submitCommandBuffer(kForce_SyncQueue)) {
        return false;
    }
    void* mappedMemory = transferBuffer->map();
    if (!mappedMemory) {
        return false;
    }
 
    SkRectMemcpy(buffer, rowBytes, mappedMemory, transBufferRowBytes, tightRowBytes, rect.height());
 
    transferBuffer->unmap();
    return true;
}

◆ onRegenerateMipMapLevels()

bool GrVkGpu::onRegenerateMipMapLevels ( GrTexture * tex )

overridevirtual

Implements GrGpu.

Definition at line 1524 of file GrVkGpu.cpp.

                                                     {
    if (!this->currentCommandBuffer()) {
        return false;
    }
    auto* vkTex = static_cast<GrVkTexture*>(tex)->textureImage();
    // don't do anything for linearly tiled textures (can't have mipmaps)
    if (vkTex->isLinearTiled()) {
        SkDebugf("Trying to create mipmap for linear tiled texture");
        return false;
    }
    SkASSERT(tex->textureType() == GrTextureType::k2D);
 
    // determine if we can blit to and from this format
    const GrVkCaps& caps = this->vkCaps();
    if (!caps.formatCanBeDstofBlit(vkTex->imageFormat(), false) ||
        !caps.formatCanBeSrcofBlit(vkTex->imageFormat(), false) ||
        !caps.mipmapSupport()) {
        return false;
    }
 
    int width = tex->width();
    int height = tex->height();
    VkImageBlit blitRegion;
    memset(&blitRegion, 0, sizeof(VkImageBlit));
 
    // SkMipmap doesn't include the base level in the level count so we have to add 1
    uint32_t levelCount = SkMipmap::ComputeLevelCount(tex->width(), tex->height()) + 1;
    SkASSERT(levelCount == vkTex->mipLevels());
 
    // change layout of the layers so we can write to them.
    vkTex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT,
                          VK_PIPELINE_STAGE_TRANSFER_BIT, false);
 
    // setup memory barrier
    SkASSERT(GrVkFormatIsSupported(vkTex->imageFormat()));
    VkImageMemoryBarrier imageMemoryBarrier = {
            VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,  // sType
            nullptr,                                 // pNext
            VK_ACCESS_TRANSFER_WRITE_BIT,            // srcAccessMask
            VK_ACCESS_TRANSFER_READ_BIT,             // dstAccessMask
            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,    // oldLayout
            VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,    // newLayout
            VK_QUEUE_FAMILY_IGNORED,                 // srcQueueFamilyIndex
            VK_QUEUE_FAMILY_IGNORED,                 // dstQueueFamilyIndex
            vkTex->image(),                          // image
            {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}  // subresourceRange
    };
 
    // Blit the miplevels
    uint32_t mipLevel = 1;
    while (mipLevel < levelCount) {
        int prevWidth = width;
        int prevHeight = height;
        width = std::max(1, width / 2);
        height = std::max(1, height / 2);
 
        imageMemoryBarrier.subresourceRange.baseMipLevel = mipLevel - 1;
        this->addImageMemoryBarrier(vkTex->resource(), VK_PIPELINE_STAGE_TRANSFER_BIT,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, false, &imageMemoryBarrier);
 
        blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel - 1, 0, 1 };
        blitRegion.srcOffsets[0] = { 0, 0, 0 };
        blitRegion.srcOffsets[1] = { prevWidth, prevHeight, 1 };
        blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 0, 1 };
        blitRegion.dstOffsets[0] = { 0, 0, 0 };
        blitRegion.dstOffsets[1] = { width, height, 1 };
        this->currentCommandBuffer()->blitImage(this,
                                                vkTex->resource(),
                                                vkTex->image(),
                                                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                                vkTex->resource(),
                                                vkTex->image(),
                                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                1,
                                                &blitRegion,
                                                VK_FILTER_LINEAR);
        ++mipLevel;
    }
    if (levelCount > 1) {
        // This barrier logically is not needed, but it changes the final level to the same layout
        // as all the others, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL. This makes tracking of the
        // layouts and future layout changes easier. The alternative here would be to track layout
        // and memory accesses per layer which doesn't seem work it.
        imageMemoryBarrier.subresourceRange.baseMipLevel = mipLevel - 1;
        this->addImageMemoryBarrier(vkTex->resource(), VK_PIPELINE_STAGE_TRANSFER_BIT,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, false, &imageMemoryBarrier);
        vkTex->updateImageLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
    }
    return true;
}

◆ onReportSubmitHistograms()

void GrVkGpu::onReportSubmitHistograms ( )

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 2271 of file GrVkGpu.cpp.

                                       {
#if SK_HISTOGRAMS_ENABLED
    uint64_t allocatedMemory = 0, usedMemory = 0;
    std::tie(allocatedMemory, usedMemory) = fMemoryAllocator->totalAllocatedAndUsedMemory();
    SkASSERT(usedMemory <= allocatedMemory);
    if (allocatedMemory > 0) {
        SK_HISTOGRAM_PERCENTAGE("VulkanMemoryAllocator.PercentUsed",
                                (usedMemory * 100) / allocatedMemory);
    }
    // allocatedMemory is in bytes and need to be reported it in kilobytes. SK_HISTOGRAM_MEMORY_KB
    // supports samples up to around 500MB which should support the amounts of memory we allocate.
    SK_HISTOGRAM_MEMORY_KB("VulkanMemoryAllocator.AmountAllocated", allocatedMemory >> 10);
#endif  // SK_HISTOGRAMS_ENABLED
}

◆ onResolveRenderTarget()

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

overridevirtual

Implements GrGpu.

Definition at line 822 of file GrVkGpu.cpp.

                                                                                      {
    SkASSERT(target->numSamples() > 1);
    GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(target);
    SkASSERT(rt->colorAttachmentView() && rt->resolveAttachmentView());
 
    if (this->vkCaps().renderTargetSupportsDiscardableMSAA(rt)) {
        // We would have resolved the RT during the render pass;
        return;
    }
 
    this->resolveImage(target, rt, resolveRect,
                       SkIPoint::Make(resolveRect.x(), resolveRect.y()));
}

◆ onSubmitToGpu()

bool GrVkGpu::onSubmitToGpu ( GrSyncCpu sync )

overrideprivatevirtual

Implements GrGpu.

Definition at line 2255 of file GrVkGpu.cpp.

                                          {
    if (sync == GrSyncCpu::kYes) {
        return this->submitCommandBuffer(kForce_SyncQueue);
    } else {
        return this->submitCommandBuffer(kSkip_SyncQueue);
    }
}

◆ onTransferFromBufferToBuffer()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 608 of file GrVkGpu.cpp.

                                                        {
    if (!this->currentCommandBuffer()) {
        return false;
    }
 
    VkBufferCopy copyRegion;
    copyRegion.srcOffset = srcOffset;
    copyRegion.dstOffset = dstOffset;
    copyRegion.size = size;
 
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(dst.get()),
                                        dstOffset,
                                        size,
                                        /*after=*/false);
    this->currentCommandBuffer()->copyBuffer(this, std::move(src), dst, 1, &copyRegion);
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(dst.get()),
                                        dstOffset,
                                        size,
                                        /*after=*/true);
 
    return true;
}

◆ onTransferPixelsFrom()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 710 of file GrVkGpu.cpp.

                                                  {
    if (!this->currentCommandBuffer()) {
        return false;
    }
    SkASSERT(surface);
    SkASSERT(transferBuffer);
    if (fProtectedContext == GrProtected::kYes) {
        return false;
    }
 
    GrVkImage* srcImage;
    if (GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(surface->asRenderTarget())) {
        // Reading from render targets that wrap a secondary command buffer is not allowed since
        // it would require us to know the VkImage, which we don't have, as well as need us to
        // stop and start the VkRenderPass which we don't have access to.
        if (rt->wrapsSecondaryCommandBuffer()) {
            return false;
        }
        if (!rt->nonMSAAAttachment()) {
            return false;
        }
        srcImage = rt->nonMSAAAttachment();
    } else {
        SkASSERT(surface->asTexture());
        srcImage = static_cast<GrVkTexture*>(surface->asTexture())->textureImage();
    }
 
    VkFormat format = srcImage->imageFormat();
    if (bufferColorType != this->vkCaps().transferColorType(format, surfaceColorType)) {
        return false;
    }
    SkASSERT(skgpu::VkFormatBytesPerBlock(format) == GrColorTypeBytesPerPixel(bufferColorType));
 
    // Set up copy region
    VkBufferImageCopy region;
    memset(&region, 0, sizeof(VkBufferImageCopy));
    region.bufferOffset = offset;
    region.bufferRowLength = rect.width();
    region.bufferImageHeight = 0;
    region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
    region.imageOffset = {rect.left(), rect.top(), 0};
    region.imageExtent = {(uint32_t)rect.width(), (uint32_t)rect.height(), 1};
 
    srcImage->setImageLayout(this,
                             VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                             VK_ACCESS_TRANSFER_READ_BIT,
                             VK_PIPELINE_STAGE_TRANSFER_BIT,
                             false);
 
    this->currentCommandBuffer()->copyImageToBuffer(this, srcImage,
                                                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                                    transferBuffer, 1, &region);
 
    GrVkBuffer* vkBuffer = static_cast<GrVkBuffer*>(transferBuffer.get());
    // Make sure the copy to buffer has finished.
    vkBuffer->addMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT,
                               VK_ACCESS_HOST_READ_BIT,
                               VK_PIPELINE_STAGE_TRANSFER_BIT,
                               VK_PIPELINE_STAGE_HOST_BIT,
                               false);
    return true;
}

◆ onTransferPixelsTo()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 637 of file GrVkGpu.cpp.

                                                  {
    if (!this->currentCommandBuffer()) {
        return false;
    }
 
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    if (GrBackendFormatBytesPerPixel(texture->backendFormat()) != bpp) {
        return false;
    }
 
    // Vulkan only supports offsets that are both 4-byte aligned and aligned to a pixel.
    if ((bufferOffset & 0x3) || (bufferOffset % bpp)) {
        return false;
    }
    GrVkTexture* tex = static_cast<GrVkTexture*>(texture);
    if (!tex) {
        return false;
    }
    GrVkImage* vkImage = tex->textureImage();
    VkFormat format = vkImage->imageFormat();
 
    // Can't transfer compressed data
    SkASSERT(!skgpu::VkFormatIsCompressed(format));
 
    if (!transferBuffer) {
        return false;
    }
 
    if (bufferColorType != this->vkCaps().transferColorType(format, surfaceColorType)) {
        return false;
    }
    SkASSERT(skgpu::VkFormatBytesPerBlock(format) == GrColorTypeBytesPerPixel(bufferColorType));
 
    SkASSERT(SkIRect::MakeSize(texture->dimensions()).contains(rect));
 
    // Set up copy region
    VkBufferImageCopy region;
    memset(&region, 0, sizeof(VkBufferImageCopy));
    region.bufferOffset = bufferOffset;
    region.bufferRowLength = (uint32_t)(rowBytes/bpp);
    region.bufferImageHeight = 0;
    region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
    region.imageOffset = { rect.left(), rect.top(), 0 };
    region.imageExtent = { (uint32_t)rect.width(), (uint32_t)rect.height(), 1 };
 
    // Change layout of our target so it can be copied to
    vkImage->setImageLayout(this,
                            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                            VK_ACCESS_TRANSFER_WRITE_BIT,
                            VK_PIPELINE_STAGE_TRANSFER_BIT,
                            false);
 
    const GrVkBuffer* vkBuffer = static_cast<GrVkBuffer*>(transferBuffer.get());
 
    // Copy the buffer to the image.
    this->currentCommandBuffer()->copyBufferToImage(this,
                                                    vkBuffer->vkBuffer(),
                                                    vkImage,
                                                    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                    1,
                                                    &region);
    this->currentCommandBuffer()->addGrBuffer(std::move(transferBuffer));
 
    tex->markMipmapsDirty();
    return true;
}

◆ onUpdateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1835 of file GrVkGpu.cpp.

                                                            {
    GrVkImageInfo info;
    SkAssertResult(GrBackendTextures::GetVkImageInfo(backendTexture, &info));
 
    sk_sp<skgpu::MutableTextureState> mutableState = backendTexture.getMutableState();
    SkASSERT(mutableState);
    sk_sp<GrVkTexture> texture = GrVkTexture::MakeWrappedTexture(this,
                                                                 backendTexture.dimensions(),
                                                                 kBorrow_GrWrapOwnership,
                                                                 GrWrapCacheable::kNo,
                                                                 kRW_GrIOType,
                                                                 info,
                                                                 std::move(mutableState));
    if (!texture) {
        return false;
    }
 
    GrVkPrimaryCommandBuffer* cmdBuffer = this->currentCommandBuffer();
    if (!cmdBuffer) {
        return false;
    }
    GrVkImage* image = texture->textureImage();
    image->setImageLayout(this,
                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                          VK_ACCESS_TRANSFER_WRITE_BIT,
                          VK_PIPELINE_STAGE_TRANSFER_BIT,
                          false);
 
    SkTextureCompressionType compression =
            GrBackendFormatToCompressionType(backendTexture.getBackendFormat());
 
    TArray<VkBufferImageCopy> regions;
    TArray<size_t> individualMipOffsets;
    GrStagingBufferManager::Slice slice;
 
    fill_in_compressed_regions(&fStagingBufferManager,
                               &regions,
                               &individualMipOffsets,
                               &slice,
                               compression,
                               info.fFormat,
                               backendTexture.dimensions(),
                               backendTexture.fMipmapped);
 
    if (!slice.fBuffer) {
        return false;
    }
 
    memcpy(slice.fOffsetMapPtr, data, size);
 
    cmdBuffer->addGrSurface(texture);
    // Copy the buffer to the image. This call takes the raw VkBuffer instead of a GrGpuBuffer
    // because we don't need the command buffer to ref the buffer here. The reason being is that
    // the buffer is coming from the staging manager and the staging manager will make sure the
    // command buffer has a ref on the buffer. This avoids having to add and remove a ref for
    // every upload in the frame.
    cmdBuffer->copyBufferToImage(this,
                                 static_cast<GrVkBuffer*>(slice.fBuffer)->vkBuffer(),
                                 image,
                                 image->currentLayout(),
                                 regions.size(),
                                 regions.begin());
 
    // Change image layout to shader read since if we use this texture as a borrowed
    // texture within Ganesh we require that its layout be set to that
    image->setImageLayout(this,
                          VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                          VK_ACCESS_SHADER_READ_BIT,
                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                          false);
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
    return true;
}

◆ onWrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrVkGpu::onWrapBackendRenderTarget ( const GrBackendRenderTarget & backendRT )

overrideprivatevirtual

Implements GrGpu.

Definition at line 1462 of file GrVkGpu.cpp.

                                                                                               {
    GrVkImageInfo info;
    if (!GrBackendRenderTargets::GetVkImageInfo(backendRT, &info)) {
        return nullptr;
    }
 
    if (!check_image_info(this->vkCaps(), info, false, this->queueIndex())) {
        return nullptr;
    }
 
    // We will always render directly to this VkImage.
    static bool kResolveOnly = false;
    if (!check_rt_image_info(this->vkCaps(), info, kResolveOnly)) {
        return nullptr;
    }
 
    if (backendRT.isProtected() && (fProtectedContext == GrProtected::kNo)) {
        return nullptr;
    }
 
    sk_sp<skgpu::MutableTextureState> mutableState = backendRT.getMutableState();
    SkASSERT(mutableState);
 
    sk_sp<GrVkRenderTarget> tgt = GrVkRenderTarget::MakeWrappedRenderTarget(
            this, backendRT.dimensions(), backendRT.sampleCnt(), info, std::move(mutableState));
 
    // We don't allow the client to supply a premade stencil buffer. We always create one if needed.
    SkASSERT(!backendRT.stencilBits());
    if (tgt) {
        SkASSERT(tgt->canAttemptStencilAttachment(tgt->numSamples() > 1));
    }
 
    return tgt;
}

◆ onWrapBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1389 of file GrVkGpu.cpp.

                                                                {
    GrVkImageInfo imageInfo;
    if (!GrBackendTextures::GetVkImageInfo(backendTex, &imageInfo)) {
        return nullptr;
    }
 
    if (!check_image_info(this->vkCaps(), imageInfo, kAdopt_GrWrapOwnership == ownership,
                          this->queueIndex())) {
        return nullptr;
    }
 
    if (!check_tex_image_info(this->vkCaps(), imageInfo)) {
        return nullptr;
    }
 
    if (backendTex.isProtected() && (fProtectedContext == GrProtected::kNo)) {
        return nullptr;
    }
 
    sk_sp<skgpu::MutableTextureState> mutableState = backendTex.getMutableState();
    SkASSERT(mutableState);
    return GrVkTexture::MakeWrappedTexture(this, backendTex.dimensions(), ownership, cacheable,
                                           ioType, imageInfo, std::move(mutableState));
}

◆ onWrapCompressedBackendTexture()

sk_sp< GrTexture > GrVkGpu::onWrapCompressedBackendTexture	(	const GrBackendTexture &	beTex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1417 of file GrVkGpu.cpp.

                                                                                    {
    return this->onWrapBackendTexture(beTex, ownership, cacheable, kRead_GrIOType);
}

◆ onWrapRenderableBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1423 of file GrVkGpu.cpp.

                                                                                    {
    GrVkImageInfo imageInfo;
    if (!GrBackendTextures::GetVkImageInfo(backendTex, &imageInfo)) {
        return nullptr;
    }
 
    if (!check_image_info(this->vkCaps(), imageInfo, kAdopt_GrWrapOwnership == ownership,
                          this->queueIndex())) {
        return nullptr;
    }
 
    if (!check_tex_image_info(this->vkCaps(), imageInfo)) {
        return nullptr;
    }
    // If sampleCnt is > 1 we will create an intermediate MSAA VkImage and then resolve into
    // the wrapped VkImage.
    bool resolveOnly = sampleCnt > 1;
    if (!check_rt_image_info(this->vkCaps(), imageInfo, resolveOnly)) {
        return nullptr;
    }
 
    if (backendTex.isProtected() && (fProtectedContext == GrProtected::kNo)) {
        return nullptr;
    }
 
    sampleCnt = this->vkCaps().getRenderTargetSampleCount(sampleCnt, imageInfo.fFormat);
 
    sk_sp<skgpu::MutableTextureState> mutableState = backendTex.getMutableState();
    SkASSERT(mutableState);
 
    return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, backendTex.dimensions(),
                                                                   sampleCnt, ownership, cacheable,
                                                                   imageInfo,
                                                                   std::move(mutableState));
}

◆ onWrapVulkanSecondaryCBAsRenderTarget()

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

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 1497 of file GrVkGpu.cpp.

                                                                      {
    int maxSize = this->caps()->maxTextureSize();
    if (imageInfo.width() > maxSize || imageInfo.height() > maxSize) {
        return nullptr;
    }
 
    GrBackendFormat backendFormat = GrBackendFormats::MakeVk(vkInfo.fFormat);
    if (!backendFormat.isValid()) {
        return nullptr;
    }
    int sampleCnt = this->vkCaps().getRenderTargetSampleCount(1, vkInfo.fFormat);
    if (!sampleCnt) {
        return nullptr;
    }
 
    return GrVkRenderTarget::MakeSecondaryCBRenderTarget(this, imageInfo.dimensions(), vkInfo);
}

◆ onWritePixels()

bool GrVkGpu::onWritePixels	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	srcColorType,
		const GrMipLevel	texels[],
		int	mipLevelCount,
		bool	prepForTexSampling
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 494 of file GrVkGpu.cpp.

                                                     {
    GrVkTexture* texture = static_cast<GrVkTexture*>(surface->asTexture());
    if (!texture) {
        return false;
    }
    GrVkImage* texImage = texture->textureImage();
 
    // Make sure we have at least the base level
    if (!mipLevelCount || !texels[0].fPixels) {
        return false;
    }
 
    SkASSERT(!skgpu::VkFormatIsCompressed(texImage->imageFormat()));
    bool success = false;
    bool linearTiling = texImage->isLinearTiled();
    if (linearTiling) {
        if (mipLevelCount > 1) {
            SkDebugf("Can't upload mipmap data to linear tiled texture");
            return false;
        }
        if (VK_IMAGE_LAYOUT_PREINITIALIZED != texImage->currentLayout()) {
            // Need to change the layout to general in order to perform a host write
            texImage->setImageLayout(this,
                                     VK_IMAGE_LAYOUT_GENERAL,
                                     VK_ACCESS_HOST_WRITE_BIT,
                                     VK_PIPELINE_STAGE_HOST_BIT,
                                     false);
            if (!this->submitCommandBuffer(kForce_SyncQueue)) {
                return false;
            }
        }
        success = this->uploadTexDataLinear(texImage,
                                            rect,
                                            srcColorType,
                                            texels[0].fPixels,
                                            texels[0].fRowBytes);
    } else {
        SkASSERT(mipLevelCount <= (int)texImage->mipLevels());
        success = this->uploadTexDataOptimal(texImage,
                                             rect,
                                             srcColorType,
                                             texels,
                                             mipLevelCount);
        if (1 == mipLevelCount) {
            texture->markMipmapsDirty();
        }
    }
 
    if (prepForTexSampling) {
        texImage->setImageLayout(this,
                                      VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                      VK_ACCESS_SHADER_READ_BIT,
                                      VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                                      false);
    }
 
    return success;
}

◆ physicalDevice()

VkPhysicalDevice GrVkGpu::physicalDevice ( ) const

inline

Definition at line 70 of file GrVkGpu.h.

70{ return fPhysicalDevice; }

◆ physicalDeviceMemoryProperties()

const VkPhysicalDeviceMemoryProperties & GrVkGpu::physicalDeviceMemoryProperties ( ) const

inline

Definition at line 78 of file GrVkGpu.h.

                                                                                   {
        return fPhysDevMemProps;
    }

◆ physicalDeviceProperties()

const VkPhysicalDeviceProperties & GrVkGpu::physicalDeviceProperties ( ) const

inline

Definition at line 75 of file GrVkGpu.h.

                                                                       {
        return fPhysDevProps;
    }

◆ pipelineBuilder()

GrThreadSafePipelineBuilder * GrVkGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 314 of file GrVkGpu.cpp.

                                                      {
    return fResourceProvider.pipelineStateCache();
}

◆ prepareSurfacesForBackendAccessAndStateUpdates()

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

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 2202 of file GrVkGpu.cpp.

                                                  {
    // Submit the current command buffer to the Queue. Whether we inserted semaphores or not does
    // not effect what we do here.
    if (!proxies.empty() && (access == SkSurfaces::BackendSurfaceAccess::kPresent || newState)) {
        // 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. Additionally if we have a newState than we must not have any
        // BackendSurfaceAccess.
        SkASSERT(!newState || proxies.size() == 1);
        SkASSERT(!newState || access == SkSurfaces::BackendSurfaceAccess::kNoAccess);
        GrVkImage* image;
        for (GrSurfaceProxy* proxy : proxies) {
            SkASSERT(proxy->isInstantiated());
            if (GrTexture* tex = proxy->peekTexture()) {
                image = static_cast<GrVkTexture*>(tex)->textureImage();
            } else {
                GrRenderTarget* rt = proxy->peekRenderTarget();
                SkASSERT(rt);
                GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
                image = vkRT->externalAttachment();
            }
            if (newState) {
                VkImageLayout newLayout =
                    skgpu::MutableTextureStates::GetVkImageLayout(newState);
                uint32_t newIndex =
                    skgpu::MutableTextureStates::GetVkQueueFamilyIndex(newState);
                set_layout_and_queue_from_mutable_state(this, image, newLayout, newIndex);
            } else {
                SkASSERT(access == SkSurfaces::BackendSurfaceAccess::kPresent);
                image->prepareForPresent(this);
            }
        }
    }
}

◆ prepareTextureForCrossContextUsage()

std::unique_ptr< GrSemaphore > GrVkGpu::prepareTextureForCrossContextUsage ( GrTexture * )

overridevirtual

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.

Implements GrGpu.

Definition at line 2748 of file GrVkGpu.cpp.

                                                                                         {
    SkASSERT(texture);
    GrVkImage* vkTexture = static_cast<GrVkTexture*>(texture)->textureImage();
    vkTexture->setImageLayout(this,
                              VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                              VK_ACCESS_SHADER_READ_BIT,
                              VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                              false);
    // TODO: should we have a way to notify the caller that this has failed? Currently if the submit
    // fails (caused by DEVICE_LOST) this will just cause us to fail the next use of the gpu.
    // Eventually we will abandon the whole GPU if this fails.
    this->submitToGpu(GrSyncCpu::kNo);
 
    // The image layout change serves as a barrier, so no semaphore is needed.
    // If we ever decide we need to return a semaphore here, we need to make sure GrVkSemaphore is
    // thread safe so that only the first thread that tries to use the semaphore actually submits
    // it. This additionally would also require thread safety in command buffer submissions to
    // queues in general.
    return nullptr;
}

◆ protectedContext()

bool GrVkGpu::protectedContext ( ) const

inline

Definition at line 81 of file GrVkGpu.h.

81{ return fProtectedContext == skgpu::Protected::kYes; }

◆ queue()

VkQueue GrVkGpu::queue ( ) const

inline

Definition at line 72 of file GrVkGpu.h.

72{ return fQueue; }

◆ queueIndex()

uint32_t GrVkGpu::queueIndex ( ) const

inline

Definition at line 73 of file GrVkGpu.h.

73{ return fQueueIndex; }

◆ refPipelineBuilder()

sk_sp< GrThreadSafePipelineBuilder > GrVkGpu::refPipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 318 of file GrVkGpu.cpp.

                                                               {
    return fResourceProvider.refPipelineStateCache();
}

◆ releaseUnlockedBackendObjects()

void GrVkGpu::releaseUnlockedBackendObjects ( )

inlineoverridevirtual

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 from GrGpu.

Definition at line 53 of file GrVkGpu.h.

                                                  {
        fResourceProvider.releaseUnlockedBackendObjects();
    }

◆ resourceProvider()

GrVkResourceProvider & GrVkGpu::resourceProvider ( )

inline

Definition at line 83 of file GrVkGpu.h.

83{ return fResourceProvider; }

◆ setBackendRenderTargetState()

bool GrVkGpu::setBackendRenderTargetState	(	const GrBackendRenderTarget &	backendRenderTarget,
		const skgpu::MutableTextureState &	newState,
		skgpu::MutableTextureState *	previousState,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback
	)

overridevirtual

Reimplemented from GrGpu.

Definition at line 1988 of file GrVkGpu.cpp.

                                                                                         {
    GrVkImageInfo info;
    SkAssertResult(GrBackendRenderTargets::GetVkImageInfo(backendRenderTarget, &info));
    sk_sp<skgpu::MutableTextureState> currentState = backendRenderTarget.getMutableState();
    SkASSERT(currentState);
    SkASSERT(newState.backend() == skgpu::BackendApi::kVulkan);
    return this->setBackendSurfaceState(info, std::move(currentState),
                                        backendRenderTarget.dimensions(),
                                        skgpu::MutableTextureStates::GetVkImageLayout(newState),
                                        skgpu::MutableTextureStates::GetVkQueueFamilyIndex(newState),
                                        previousState, std::move(finishedCallback));
}

◆ setBackendTextureState()

bool GrVkGpu::setBackendTextureState	(	const GrBackendTexture &	backendTeture,
		const skgpu::MutableTextureState &	newState,
		skgpu::MutableTextureState *	previousState,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback
	)

overridevirtual

Reimplemented from GrGpu.

Definition at line 1972 of file GrVkGpu.cpp.

                                                                                    {
    GrVkImageInfo info;
    SkAssertResult(GrBackendTextures::GetVkImageInfo(backendTeture, &info));
    sk_sp<skgpu::MutableTextureState> currentState = backendTeture.getMutableState();
    SkASSERT(currentState);
    SkASSERT(newState.isValid() && newState.backend() == skgpu::BackendApi::kVulkan);
    return this->setBackendSurfaceState(info, std::move(currentState), backendTeture.dimensions(),
                                        skgpu::MutableTextureStates::GetVkImageLayout(newState),
                                        skgpu::MutableTextureStates::GetVkQueueFamilyIndex(newState),
                                        previousState,
                                        std::move(finishedCallback));
}

◆ stagingBufferManager()

GrStagingBufferManager * GrVkGpu::stagingBufferManager ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 63 of file GrVkGpu.h.

63{ return &fStagingBufferManager; }

◆ storeVkPipelineCacheData()

void GrVkGpu::storeVkPipelineCacheData ( )

overridevirtual

Reimplemented from GrGpu.

Definition at line 2773 of file GrVkGpu.cpp.

                                       {
    if (this->getContext()->priv().getPersistentCache()) {
        this->resourceProvider().storePipelineCacheData();
    }
}

◆ submit()

void GrVkGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 2706 of file GrVkGpu.cpp.

                                                {
    SkASSERT(fCachedOpsRenderPass.get() == renderPass);
 
    fCachedOpsRenderPass->submit();
    fCachedOpsRenderPass->reset();
}

◆ submitSecondaryCommandBuffer()

void GrVkGpu::submitSecondaryCommandBuffer ( std::unique_ptr< GrVkSecondaryCommandBuffer > buffer )

Definition at line 2699 of file GrVkGpu.cpp.

                                                                                           {
    if (!this->currentCommandBuffer()) {
        return;
    }
    this->currentCommandBuffer()->executeCommands(this, std::move(buffer));
}

◆ takeOwnershipOfBuffer()

void GrVkGpu::takeOwnershipOfBuffer ( sk_sp< GrGpuBuffer > buffer )

overridevirtual

Reimplemented from GrGpu.

Definition at line 2251 of file GrVkGpu.cpp.

                                                             {
    this->currentCommandBuffer()->addGrBuffer(std::move(buffer));
}

◆ updateBuffer()

bool GrVkGpu::updateBuffer	(	sk_sp< GrVkBuffer >	buffer,
		const void *	src,
		VkDeviceSize	offset,
		VkDeviceSize	size
	)

Definition at line 1245 of file GrVkGpu.cpp.

                                                                   {
    if (!this->currentCommandBuffer()) {
        return false;
    }
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(buffer.get()),
                                        offset,
                                        size,
                                        /*after=*/false);
    this->currentCommandBuffer()->updateBuffer(this, buffer, offset, size, src);
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(buffer.get()),
                                        offset,
                                        size,
                                        /*after=*/true);
 
    return true;
}

◆ vkCaps()

const GrVkCaps & GrVkGpu::vkCaps ( ) const

inline

Definition at line 61 of file GrVkGpu.h.

61{ return *fVkCaps; }

◆ vkInterface()

const skgpu::VulkanInterface * GrVkGpu::vkInterface ( ) const

inline

Definition at line 60 of file GrVkGpu.h.

60{ return fInterface.get(); }

◆ waitSemaphore()

void GrVkGpu::waitSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 2736 of file GrVkGpu.cpp.

                                                  {
    SkASSERT(semaphore);
 
    GrVkSemaphore* vkSem = static_cast<GrVkSemaphore*>(semaphore);
 
    GrVkSemaphore::Resource* resource = vkSem->getResource();
    if (resource->shouldWait()) {
        resource->ref();
        fSemaphoresToWaitOn.push_back(resource);
    }
}

◆ wrapBackendSemaphore()

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

overridevirtual

Implements GrGpu.

Definition at line 2717 of file GrVkGpu.cpp.

                                                                                      {
    return GrVkSemaphore::MakeWrapped(this, GrBackendSemaphores::GetVkSemaphore(semaphore),
                                      wrapType, ownership);
}

◆ xferBarrier()

void GrVkGpu::xferBarrier	(	GrRenderTarget *	rt,
		GrXferBarrierType	barrierType
	)

overridevirtual

Implements GrGpu.

Definition at line 2004 of file GrVkGpu.cpp.

                                                                           {
    GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
    VkPipelineStageFlags dstStage;
    VkAccessFlags dstAccess;
    if (barrierType == kBlend_GrXferBarrierType) {
        dstStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dstAccess = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT;
    } else {
        SkASSERT(barrierType == kTexture_GrXferBarrierType);
        dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
        dstAccess = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
    }
    GrVkImage* image = vkRT->colorAttachment();
    VkImageMemoryBarrier barrier;
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.pNext = nullptr;
    barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    barrier.dstAccessMask = dstAccess;
    barrier.oldLayout = image->currentLayout();
    barrier.newLayout = barrier.oldLayout;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = image->image();
    barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, image->mipLevels(), 0, 1};
    this->addImageMemoryBarrier(image->resource(),
                                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                                dstStage, true, &barrier);
}

◆ zeroBuffer()

bool GrVkGpu::zeroBuffer ( sk_sp< GrGpuBuffer > buffer )

Definition at line 1265 of file GrVkGpu.cpp.

                                                  {
    if (!this->currentCommandBuffer()) {
        return false;
    }
 
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(buffer.get()),
                                        /*offset=*/0,
                                        buffer->size(),
                                        /*after=*/false);
    this->currentCommandBuffer()->fillBuffer(this,
                                             buffer,
                                             /*offset=*/0,
                                             buffer->size(),
                                             /*data=*/0);
    add_transfer_dst_buffer_mem_barrier(this,
                                        static_cast<GrVkBuffer*>(buffer.get()),
                                        /*offset=*/0,
                                        buffer->size(),
                                        /*after=*/true);
 
    return true;
}

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

third_party/skia/src/gpu/ganesh/vk/GrVkGpu.h
third_party/skia/src/gpu/ganesh/vk/GrVkGpu.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SubmitContext

◆ SubmitProc

Member Enumeration Documentation

◆ PersistentCacheKeyType

Constructor & Destructor Documentation

◆ ~GrVkGpu()

Member Function Documentation

◆ addBufferMemoryBarrier() [1/2]

◆ addBufferMemoryBarrier() [2/2]

◆ addDrawable()

◆ addFinishedProc()

◆ addImageMemoryBarrier()

◆ beginRenderPass()

◆ checkFinishProcs()

◆ checkVkResult()

◆ cmdPool()

◆ compile()

◆ currentCommandBuffer()

◆ deleteBackendTexture()

◆ device()

◆ disconnect()

◆ disconnected()

◆ endRenderPass()

◆ finishOutstandingGpuWork()

◆ getPreferredStencilFormat()

◆ insertSemaphore()

◆ isDeviceLost()

◆ loadMSAAFromResolve()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ memoryAllocator()

◆ onClearBackendTexture()

◆ onCopySurface()

◆ onCreateBackendTexture()

◆ onCreateBuffer()

◆ onCreateCompressedBackendTexture()

◆ onCreateCompressedTexture()

◆ onCreateTexture()

◆ onGetOpsRenderPass()

◆ onReadPixels()

◆ onRegenerateMipMapLevels()

◆ onReportSubmitHistograms()

◆ onResolveRenderTarget()

◆ onSubmitToGpu()

◆ onTransferFromBufferToBuffer()

◆ onTransferPixelsFrom()

◆ onTransferPixelsTo()

◆ onUpdateCompressedBackendTexture()

◆ onWrapBackendRenderTarget()

◆ onWrapBackendTexture()

◆ onWrapCompressedBackendTexture()

◆ onWrapRenderableBackendTexture()

◆ onWrapVulkanSecondaryCBAsRenderTarget()

◆ onWritePixels()

◆ physicalDevice()

◆ physicalDeviceMemoryProperties()

◆ physicalDeviceProperties()

◆ pipelineBuilder()

◆ prepareSurfacesForBackendAccessAndStateUpdates()

◆ prepareTextureForCrossContextUsage()

◆ protectedContext()

◆ queue()

◆ queueIndex()

◆ refPipelineBuilder()

◆ releaseUnlockedBackendObjects()

◆ resourceProvider()

◆ setBackendRenderTargetState()

◆ setBackendTextureState()

◆ stagingBufferManager()

◆ storeVkPipelineCacheData()

◆ submit()