#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 GrStagingBufferManager *	stagingBufferManager ()

virtual GrRingBuffer *	uniformsRingBuffer ()

virtual void	disconnect (DisconnectType)

virtual GrThreadSafePipelineBuilder *	pipelineBuilder ()=0

virtual sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder ()=0

virtual bool	isDeviceLost () const

void	markContextDirty (uint32_t state=kAll_GrBackendState)

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

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

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

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

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

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

sk_sp< GrRenderTarget >	wrapBackendRenderTarget (const GrBackendRenderTarget &)

sk_sp< GrRenderTarget >	wrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)

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

void	resolveRenderTarget (GrRenderTarget *, const SkIRect &resolveRect)

bool	regenerateMipMapLevels (GrTexture *)

void	resetTextureBindings ()

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

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

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

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

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

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

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

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

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

virtual void	willExecute ()

bool	submitToGpu (GrSyncCpu sync)

virtual void	submit (GrOpsRenderPass *)=0

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

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

virtual void	insertSemaphore (GrSemaphore *semaphore)=0

virtual void	waitSemaphore (GrSemaphore *semaphore)=0

virtual void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)=0

virtual void	checkFinishProcs ()=0

virtual void	finishOutstandingGpuWork ()=0

virtual void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)

bool	checkAndResetOOMed ()

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

virtual void	releaseUnlockedBackendObjects ()

Stats *	stats ()

void	dumpJSON (SkJSONWriter *) const

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

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

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

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

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

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

virtual void	deleteBackendTexture (const GrBackendTexture &)=0

virtual bool	compile (const GrProgramDesc &, const GrProgramInfo &)=0

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

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

virtual GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &)=0

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

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

virtual void	xferBarrier (GrRenderTarget *, GrXferBarrierType)=0

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

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 276 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 2127 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 2144 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 2753 of file GrVkGpu.cpp.

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

◆ addImageMemoryBarrier()

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

Definition at line 2164 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 2621 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 2659 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 2026 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 2017 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 286 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 2651 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 2247 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 2708 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 1500 of file GrVkGpu.cpp.

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

◆ Make()

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

static

Definition at line 70 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);
 
    skgpu::VulkanExtensions noExtensions;
    const skgpu::VulkanExtensions* extensions =
            backendContext.fVkExtensions ? backendContext.fVkExtensions : &noExtensions;
 
    auto interface = sk_make_sp<skgpu::VulkanInterface>(backendContext.fGetProc,
                                                        backendContext.fInstance,
                                                        backendContext.fDevice,
                                                        instanceVersion,
                                                        physDevVersion,
                                                        extensions);
    SkASSERT(interface);
    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,
                                *extensions,
                                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,
                                *extensions,
                                backendContext.fProtectedContext));
    } else {
        VkPhysicalDeviceFeatures2 features;
        memset(&features, 0, sizeof(VkPhysicalDeviceFeatures2));
 
        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 defined(SK_USE_VMA)
    if (!memoryAllocator) {
        // We were not given a memory allocator at creation
        memoryAllocator = skgpu::VulkanAMDMemoryAllocator::Make(backendContext.fInstance,
                                                                backendContext.fPhysicalDevice,
                                                                backendContext.fDevice,
                                                                physDevVersion,
                                                                extensions,
                                                                interface.get(),
                                                                skgpu::ThreadSafe::kNo);
    }
#endif
    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 1609 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 2697 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 1601 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(); }

sk_sp::get

T * get() const

Definition: SkRefCnt.h:303

◆ onRegenerateMipMapLevels()

bool GrVkGpu::onRegenerateMipMapLevels ( GrTexture * tex )

overridevirtual

Implements GrGpu.

Definition at line 1508 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;
}

◆ onResolveRenderTarget()

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

overridevirtual

Implements GrGpu.

Definition at line 806 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()));
}

◆ 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 298 of file GrVkGpu.cpp.

                                                      {
    return fResourceProvider.pipelineStateCache();
}

◆ 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 2732 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 302 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 1972 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 1956 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 2757 of file GrVkGpu.cpp.

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

◆ submit()

void GrVkGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 2690 of file GrVkGpu.cpp.

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

◆ submitSecondaryCommandBuffer()

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

Definition at line 2683 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 2235 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 1229 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 2720 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 2701 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 1988 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 1249 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

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()

◆ addImageMemoryBarrier()

◆ beginRenderPass()

◆ checkFinishProcs()

◆ checkVkResult()

◆ cmdPool()

◆ compile()

◆ currentCommandBuffer()

◆ deleteBackendTexture()

◆ device()

◆ disconnect()

◆ disconnected()

◆ endRenderPass()

◆ finishOutstandingGpuWork()

◆ getPreferredStencilFormat()

◆ insertSemaphore()

◆ isDeviceLost()

◆ loadMSAAFromResolve()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ memoryAllocator()

◆ onRegenerateMipMapLevels()

◆ onResolveRenderTarget()

◆ physicalDevice()

◆ physicalDeviceMemoryProperties()

◆ physicalDeviceProperties()

◆ pipelineBuilder()

◆ prepareTextureForCrossContextUsage()

◆ protectedContext()

◆ queue()

◆ queueIndex()

◆ refPipelineBuilder()

◆ releaseUnlockedBackendObjects()

◆ resourceProvider()

◆ setBackendRenderTargetState()

◆ setBackendTextureState()

◆ stagingBufferManager()

◆ storeVkPipelineCacheData()

◆ submit()

◆ submitSecondaryCommandBuffer()

◆ takeOwnershipOfBuffer()

◆ updateBuffer()

◆ vkCaps()

◆ vkInterface()

◆ waitSemaphore()

◆ wrapBackendSemaphore()

◆ xferBarrier()

◆ zeroBuffer()