#include <VulkanCommandBuffer.h>

Inheritance diagram for skgpu::graphite::VulkanCommandBuffer:

Public Member Functions
	~VulkanCommandBuffer () override

bool	setNewCommandBufferResources () override

bool	submit (VkQueue)

bool	isFinished ()

void	waitUntilFinished ()

void	addBufferMemoryBarrier (const Resource resource, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkBufferMemoryBarrier barrier)

void	addBufferMemoryBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkBufferMemoryBarrier *barrier)

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

Public Member Functions inherited from skgpu::graphite::CommandBuffer
virtual	~CommandBuffer ()

void	trackResource (sk_sp< Resource > resource)

void	trackCommandBufferResource (sk_sp< Resource > resource)

void	resetCommandBuffer ()

void	addFinishedProc (sk_sp< RefCntedCallback > finishedProc)

void	callFinishedProcs (bool success)

void	addBuffersToAsyncMapOnSubmit (SkSpan< const sk_sp< Buffer > >)

SkSpan< const sk_sp< Buffer > >	buffersToAsyncMapOnSubmit () const

bool	addRenderPass (const RenderPassDesc &, sk_sp< Texture > colorTexture, sk_sp< Texture > resolveTexture, sk_sp< Texture > depthStencilTexture, SkRect viewport, const DrawPassList &drawPasses)

bool	addComputePass (DispatchGroupSpan dispatchGroups)

bool	copyBufferToBuffer (const Buffer *srcBuffer, size_t srcOffset, sk_sp< Buffer > dstBuffer, size_t dstOffset, size_t size)

bool	copyTextureToBuffer (sk_sp< Texture >, SkIRect srcRect, sk_sp< Buffer >, size_t bufferOffset, size_t bufferRowBytes)

bool	copyBufferToTexture (const Buffer , sk_sp< Texture >, const BufferTextureCopyData , int count)

bool	copyTextureToTexture (sk_sp< Texture > src, SkIRect srcRect, sk_sp< Texture > dst, SkIPoint dstPoint, int mipLevel)

bool	synchronizeBufferToCpu (sk_sp< Buffer >)

bool	clearBuffer (const Buffer *buffer, size_t offset, size_t size)

void	setReplayTranslation (SkIVector translation)

void	clearReplayTranslation ()

Static Public Member Functions
static std::unique_ptr< VulkanCommandBuffer >	Make (const VulkanSharedContext , VulkanResourceProvider )

Private Member Functions
void	onResetCommandBuffer () override

void	addWaitSemaphores (size_t numWaitSemaphores, const BackendSemaphore *waitSemaphores) override

void	addSignalSemaphores (size_t numWaitSemaphores, const BackendSemaphore *signalSemaphores) override

void	prepareSurfaceForStateUpdate (SkSurface targetSurface, const MutableTextureState newState) override

bool	onAddRenderPass (const RenderPassDesc &, const Texture colorTexture, const Texture resolveTexture, const Texture *depthStencilTexture, SkRect viewport, const DrawPassList &) override

bool	onAddComputePass (DispatchGroupSpan) override

bool	onCopyBufferToBuffer (const Buffer srcBuffer, size_t srcOffset, const Buffer dstBuffer, size_t dstOffset, size_t size) override

bool	onCopyTextureToBuffer (const Texture , SkIRect srcRect, const Buffer , size_t bufferOffset, size_t bufferRowBytes) override

bool	onCopyBufferToTexture (const Buffer , const Texture , const BufferTextureCopyData *copyData, int count) override

bool	onCopyTextureToTexture (const Texture src, SkIRect srcRect, const Texture dst, SkIPoint dstPoint, int mipLevel) override

bool	onSynchronizeBufferToCpu (const Buffer , bool outDidResultInWork) override

bool	onClearBuffer (const Buffer *, size_t offset, size_t size) override

Additional Inherited Members
Public Types inherited from skgpu::graphite::CommandBuffer
using	DrawPassList = skia_private::TArray< std::unique_ptr< DrawPass > >

using	DispatchGroupSpan = SkSpan< const std::unique_ptr< DispatchGroup > >

Protected Member Functions inherited from skgpu::graphite::CommandBuffer
	CommandBuffer ()

Protected Attributes inherited from skgpu::graphite::CommandBuffer
SkISize	fRenderPassSize

SkIVector	fReplayTranslation

Detailed Description

Definition at line 25 of file VulkanCommandBuffer.h.

Constructor & Destructor Documentation

◆ ~VulkanCommandBuffer()

skgpu::graphite::VulkanCommandBuffer::~VulkanCommandBuffer ( )

override

Definition at line 110 of file VulkanCommandBuffer.cpp.

                                          {
    if (fActive) {
        // Need to end command buffer before deleting it
        VULKAN_CALL(fSharedContext->interface(), EndCommandBuffer(fPrimaryCommandBuffer));
        fActive = false;
    }
 
    if (VK_NULL_HANDLE != fSubmitFence) {
        VULKAN_CALL(fSharedContext->interface(),
                    DestroyFence(fSharedContext->device(), fSubmitFence, nullptr));
    }
    // This should delete any command buffers as well.
    VULKAN_CALL(fSharedContext->interface(),
                DestroyCommandPool(fSharedContext->device(), fPool, nullptr));
}

Member Function Documentation

◆ addBufferMemoryBarrier() [1/2]

void skgpu::graphite::VulkanCommandBuffer::addBufferMemoryBarrier	(	const Resource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		VkBufferMemoryBarrier *	barrier
	)

Definition at line 1484 of file VulkanCommandBuffer.cpp.

                                                                                 {
    SkASSERT(resource);
    this->pipelineBarrier(resource,
                          srcStageMask,
                          dstStageMask,
                          /*byRegion=*/false,
                          kBufferMemory_BarrierType,
                          barrier);
}

◆ addBufferMemoryBarrier() [2/2]

void skgpu::graphite::VulkanCommandBuffer::addBufferMemoryBarrier	(	VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		VkBufferMemoryBarrier *	barrier
	)

Definition at line 1497 of file VulkanCommandBuffer.cpp.

                                                                                 {
    // 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->pipelineBarrier(/*resource=*/nullptr,
                          srcStageMask,
                          dstStageMask,
                          /*byRegion=*/false,
                          kBufferMemory_BarrierType,
                          barrier);
}

◆ addImageMemoryBarrier()

void skgpu::graphite::VulkanCommandBuffer::addImageMemoryBarrier	(	const Resource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		VkImageMemoryBarrier *	barrier
	)

Definition at line 1512 of file VulkanCommandBuffer.cpp.

                                                                               {
    SkASSERT(resource);
    this->pipelineBarrier(resource,
                          srcStageMask,
                          dstStageMask,
                          byRegion,
                          kImageMemory_BarrierType,
                          barrier);
}

◆ addSignalSemaphores()

void skgpu::graphite::VulkanCommandBuffer::addSignalSemaphores	(	size_t	numWaitSemaphores,
		const BackendSemaphore *	signalSemaphores
	)

overrideprivatevirtual

Reimplemented from skgpu::graphite::CommandBuffer.

Definition at line 194 of file VulkanCommandBuffer.cpp.

                                                                                        {
    if (!signalSemaphores) {
        SkASSERT(numSignalSemaphores == 0);
        return;
    }
 
    for (size_t i = 0; i < numSignalSemaphores; ++i) {
        auto& semaphore = signalSemaphores[i];
        if (semaphore.isValid() && semaphore.backend() == BackendApi::kVulkan) {
            fSignalSemaphores.push_back(semaphore.getVkSemaphore());
        }
    }
}

◆ addWaitSemaphores()

void skgpu::graphite::VulkanCommandBuffer::addWaitSemaphores	(	size_t	numWaitSemaphores,
		const BackendSemaphore *	waitSemaphores
	)

overrideprivatevirtual

Reimplemented from skgpu::graphite::CommandBuffer.

Definition at line 179 of file VulkanCommandBuffer.cpp.

                                                                                    {
    if (!waitSemaphores) {
        SkASSERT(numWaitSemaphores == 0);
        return;
    }
 
    for (size_t i = 0; i < numWaitSemaphores; ++i) {
        auto& semaphore = waitSemaphores[i];
        if (semaphore.isValid() && semaphore.backend() == BackendApi::kVulkan) {
            fWaitSemaphores.push_back(semaphore.getVkSemaphore());
        }
    }
}

◆ isFinished()

bool skgpu::graphite::VulkanCommandBuffer::isFinished ( )

Definition at line 331 of file VulkanCommandBuffer.cpp.

                                     {
    SkASSERT(!fActive);
    if (VK_NULL_HANDLE == fSubmitFence) {
        return true;
    }
 
    VkResult err;
    VULKAN_CALL_RESULT_NOCHECK(fSharedContext->interface(), err,
                               GetFenceStatus(fSharedContext->device(), fSubmitFence));
    switch (err) {
        case VK_SUCCESS:
        case VK_ERROR_DEVICE_LOST:
            return true;
 
        case VK_NOT_READY:
            return false;
 
        default:
            SKGPU_LOG_F("Error calling vkGetFenceStatus. Error: %d", err);
            SK_ABORT("Got an invalid fence status");
            return false;
    }
}

◆ Make()

std::unique_ptr< VulkanCommandBuffer > skgpu::graphite::VulkanCommandBuffer::Make	(	const VulkanSharedContext *	sharedContext,
		VulkanResourceProvider *	resourceProvider
	)

static

Definition at line 49 of file VulkanCommandBuffer.cpp.

                                                  {
    // Create VkCommandPool
    VkCommandPoolCreateFlags cmdPoolCreateFlags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
    if (sharedContext->isProtected() == Protected::kYes) {
        cmdPoolCreateFlags |= VK_COMMAND_POOL_CREATE_PROTECTED_BIT;
    }
 
    const VkCommandPoolCreateInfo cmdPoolInfo = {
            VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,  // sType
            nullptr,                                     // pNext
            cmdPoolCreateFlags,                          // CmdPoolCreateFlags
            sharedContext->queueIndex(),                 // queueFamilyIndex
    };
    VkResult result;
    VkCommandPool pool;
    VULKAN_CALL_RESULT(sharedContext,
                       result,
                       CreateCommandPool(sharedContext->device(), &cmdPoolInfo, nullptr, &pool));
    if (result != VK_SUCCESS) {
        return nullptr;
    }
 
    const VkCommandBufferAllocateInfo cmdInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
        nullptr,                                          // pNext
        pool,                                             // commandPool
        VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // level
        1                                                 // bufferCount
    };
 
    VkCommandBuffer primaryCmdBuffer;
    VULKAN_CALL_RESULT(
            sharedContext,
            result,
            AllocateCommandBuffers(sharedContext->device(), &cmdInfo, &primaryCmdBuffer));
    if (result != VK_SUCCESS) {
        VULKAN_CALL(sharedContext->interface(),
                    DestroyCommandPool(sharedContext->device(), pool, nullptr));
        return nullptr;
    }
 
    return std::unique_ptr<VulkanCommandBuffer>(new VulkanCommandBuffer(pool,
                                                                        primaryCmdBuffer,
                                                                        sharedContext,
                                                                        resourceProvider));
}

◆ onAddComputePass()

bool skgpu::graphite::VulkanCommandBuffer::onAddComputePass ( DispatchGroupSpan )

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1295 of file VulkanCommandBuffer.cpp.

1295{ return false; }

◆ onAddRenderPass()

bool skgpu::graphite::VulkanCommandBuffer::onAddRenderPass	(	const RenderPassDesc &	renderPassDesc,
		const Texture *	colorTexture,
		const Texture *	resolveTexture,
		const Texture *	depthStencilTexture,
		SkRect	viewport,
		const DrawPassList &	drawPasses
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 397 of file VulkanCommandBuffer.cpp.

                                                                          {
    for (const auto& drawPass : drawPasses) {
        // Our current implementation of setting texture image layouts does not allow layout changes
        // once we have already begun a render pass, so prior to any other commands, set the layout
        // of all sampled textures from the drawpass so they can be sampled from the shader.
        const skia_private::TArray<sk_sp<TextureProxy>>& sampledTextureProxies =
                drawPass->sampledTextures();
        for (const sk_sp<TextureProxy>& textureProxy : sampledTextureProxies) {
            VulkanTexture* vulkanTexture = const_cast<VulkanTexture*>(
                                           static_cast<const VulkanTexture*>(
                                           textureProxy->texture()));
            vulkanTexture->setImageLayout(this,
                                          VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                          VK_ACCESS_SHADER_READ_BIT,
                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                                          false);
            this->submitPipelineBarriers();
        }
    }
 
    this->updateRtAdjustUniform(viewport);
    this->setViewport(viewport);
 
    if (!this->beginRenderPass(renderPassDesc, colorTexture, resolveTexture, depthStencilTexture)) {
        return false;
    }
 
    for (const auto& drawPass : drawPasses) {
        this->addDrawPass(drawPass.get());
    }
 
    this->endRenderPass();
    return true;
}

◆ onClearBuffer()

bool skgpu::graphite::VulkanCommandBuffer::onClearBuffer	(	const Buffer *	,
		size_t	offset,
		size_t	size
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1480 of file VulkanCommandBuffer.cpp.

                                                                                 {
    return false;
}

◆ onCopyBufferToBuffer()

bool skgpu::graphite::VulkanCommandBuffer::onCopyBufferToBuffer	(	const Buffer *	srcBuffer,
		size_t	srcOffset,
		const Buffer *	dstBuffer,
		size_t	dstOffset,
		size_t	size
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1297 of file VulkanCommandBuffer.cpp.

                                                            {
    auto vkSrcBuffer = static_cast<const VulkanBuffer*>(srcBuffer);
    auto vkDstBuffer = static_cast<const VulkanBuffer*>(dstBuffer);
 
    SkASSERT(vkSrcBuffer->bufferUsageFlags() & VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
    SkASSERT(vkDstBuffer->bufferUsageFlags() & VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 
    VkBufferCopy region;
    memset(&region, 0, sizeof(VkBufferCopy));
    region.srcOffset = srcOffset;
    region.dstOffset = dstOffset;
    region.size = size;
 
    this->submitPipelineBarriers();
 
    VULKAN_CALL(fSharedContext->interface(),
                CmdCopyBuffer(fPrimaryCommandBuffer,
                              vkSrcBuffer->vkBuffer(),
                              vkDstBuffer->vkBuffer(),
                              /*regionCount=*/1,
                              &region));
 
    return true;
}

◆ onCopyBufferToTexture()

bool skgpu::graphite::VulkanCommandBuffer::onCopyBufferToTexture	(	const Buffer *	buffer,
		const Texture *	texture,
		const BufferTextureCopyData *	copyData,
		int	count
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1374 of file VulkanCommandBuffer.cpp.

                                                           {
    auto srcBuffer = static_cast<const VulkanBuffer*>(buffer);
    SkASSERT(srcBuffer->bufferUsageFlags() & VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
    const VulkanTexture* dstTexture = static_cast<const VulkanTexture*>(texture);
 
    // Obtain the VkFormat of the destination texture so we can determine bytes per block.
    VulkanTextureInfo dstTextureInfo;
    dstTexture->textureInfo().getVulkanTextureInfo(&dstTextureInfo);
    size_t bytesPerBlock = VkFormatBytesPerBlock(dstTextureInfo.fFormat);
    SkISize oneBlockDims = CompressedDimensions(dstTexture->textureInfo().compressionType(),
                                                {1, 1});
 
    // Set up copy regions.
    TArray<VkBufferImageCopy> regions(count);
    for (int i = 0; i < count; ++i) {
        VkBufferImageCopy& region = regions.push_back();
        memset(&region, 0, sizeof(VkBufferImageCopy));
        region.bufferOffset = copyData[i].fBufferOffset;
        // copyData provides row length in bytes, but Vulkan expects bufferRowLength in texels.
        // For compressed this is the number of logical pixels not the number of blocks.
        region.bufferRowLength =
                (uint32_t)((copyData[i].fBufferRowBytes/bytesPerBlock) * oneBlockDims.fWidth);
        region.bufferImageHeight = 0; // Tightly packed
        region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, copyData[i].fMipLevel, 0, 1 };
        region.imageOffset = { copyData[i].fRect.left(),
                               copyData[i].fRect.top(),
                               /*z=*/0 };
        region.imageExtent = { (uint32_t)copyData[i].fRect.width(),
                               (uint32_t)copyData[i].fRect.height(),
                               /*depth=*/1 };
    }
 
    // Enable editing of the destination texture so we can change its layout so it can be copied to.
    const_cast<VulkanTexture*>(dstTexture)->setImageLayout(this,
                                                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                           VK_ACCESS_TRANSFER_WRITE_BIT,
                                                           VK_PIPELINE_STAGE_TRANSFER_BIT,
                                                           false);
 
    this->submitPipelineBarriers();
 
    VULKAN_CALL(fSharedContext->interface(),
            CmdCopyBufferToImage(fPrimaryCommandBuffer,
                                 srcBuffer->vkBuffer(),
                                 dstTexture->vkImage(),
                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                 regions.size(),
                                 regions.begin()));
    return true;
}

◆ onCopyTextureToBuffer()

bool skgpu::graphite::VulkanCommandBuffer::onCopyTextureToBuffer	(	const Texture *	texture,
		SkIRect	srcRect,
		const Buffer *	buffer,
		size_t	bufferOffset,
		size_t	bufferRowBytes
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1326 of file VulkanCommandBuffer.cpp.

                                                                       {
    const VulkanTexture* srcTexture = static_cast<const VulkanTexture*>(texture);
    auto dstBuffer = static_cast<const VulkanBuffer*>(buffer);
    SkASSERT(dstBuffer->bufferUsageFlags() & VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 
    // Obtain the VkFormat of the source texture so we can determine bytes per block.
    VulkanTextureInfo srcTextureInfo;
    texture->textureInfo().getVulkanTextureInfo(&srcTextureInfo);
    size_t bytesPerBlock = VkFormatBytesPerBlock(srcTextureInfo.fFormat);
 
    // Set up copy region
    VkBufferImageCopy region;
    memset(&region, 0, sizeof(VkBufferImageCopy));
    region.bufferOffset = bufferOffset;
    // Vulkan expects bufferRowLength in texels, not bytes.
    region.bufferRowLength = (uint32_t)(bufferRowBytes/bytesPerBlock);
    region.bufferImageHeight = 0; // Tightly packed
    region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, /*mipLevel=*/0, 0, 1 };
    region.imageOffset = { srcRect.left(), srcRect.top(), /*z=*/0 };
    region.imageExtent = { (uint32_t)srcRect.width(), (uint32_t)srcRect.height(), /*depth=*/1 };
 
    // Enable editing of the source texture so we can change its layout so it can be copied from.
    const_cast<VulkanTexture*>(srcTexture)->setImageLayout(this,
                                                           VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                                           VK_ACCESS_TRANSFER_READ_BIT,
                                                           VK_PIPELINE_STAGE_TRANSFER_BIT,
                                                           false);
    // Set current access mask for buffer
    const_cast<VulkanBuffer*>(dstBuffer)->setBufferAccess(this,
                                                          VK_ACCESS_TRANSFER_WRITE_BIT,
                                                          VK_PIPELINE_STAGE_TRANSFER_BIT);
 
    this->submitPipelineBarriers();
 
    VULKAN_CALL(fSharedContext->interface(),
                CmdCopyImageToBuffer(fPrimaryCommandBuffer,
                                     srcTexture->vkImage(),
                                     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                     dstBuffer->vkBuffer(),
                                     /*regionCount=*/1,
                                     &region));
    return true;
}

◆ onCopyTextureToTexture()

bool skgpu::graphite::VulkanCommandBuffer::onCopyTextureToTexture	(	const Texture *	src,
		SkIRect	srcRect,
		const Texture *	dst,
		SkIPoint	dstPoint,
		int	mipLevel
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1428 of file VulkanCommandBuffer.cpp.

                                                               {
    const VulkanTexture* srcTexture = static_cast<const VulkanTexture*>(src);
    const VulkanTexture* dstTexture = static_cast<const VulkanTexture*>(dst);
 
    VkImageCopy copyRegion;
    memset(&copyRegion, 0, sizeof(VkImageCopy));
    copyRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
    copyRegion.srcOffset = { srcRect.fLeft, srcRect.fTop, 0 };
    copyRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, (uint32_t)mipLevel, 0, 1 };
    copyRegion.dstOffset = { dstPoint.fX, dstPoint.fY, 0 };
    copyRegion.extent = { (uint32_t)srcRect.width(), (uint32_t)srcRect.height(), 1 };
 
    // Enable editing of the src texture so we can change its layout so it can be copied from.
    const_cast<VulkanTexture*>(srcTexture)->setImageLayout(this,
                                                           VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                                           VK_ACCESS_TRANSFER_READ_BIT,
                                                           VK_PIPELINE_STAGE_TRANSFER_BIT,
                                                           false);
    // Enable editing of the destination texture so we can change its layout so it can be copied to.
    const_cast<VulkanTexture*>(dstTexture)->setImageLayout(this,
                                                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                           VK_ACCESS_TRANSFER_WRITE_BIT,
                                                           VK_PIPELINE_STAGE_TRANSFER_BIT,
                                                           false);
 
    this->submitPipelineBarriers();
 
    VULKAN_CALL(fSharedContext->interface(),
                CmdCopyImage(fPrimaryCommandBuffer,
                             srcTexture->vkImage(),
                             VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                             dstTexture->vkImage(),
                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                             /*regionCount=*/1,
                             &copyRegion));
 
    return true;
}

◆ onResetCommandBuffer()

void skgpu::graphite::VulkanCommandBuffer::onResetCommandBuffer ( )

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 126 of file VulkanCommandBuffer.cpp.

                                               {
    SkASSERT(!fActive);
    VULKAN_CALL_ERRCHECK(fSharedContext, ResetCommandPool(fSharedContext->device(), fPool, 0));
    fActiveGraphicsPipeline = nullptr;
    fBindUniformBuffers = true;
    fBoundIndexBuffer = VK_NULL_HANDLE;
    fBoundIndexBufferOffset = 0;
    fBoundIndirectBuffer = VK_NULL_HANDLE;
    fBoundIndirectBufferOffset = 0;
    fTextureSamplerDescSetToBind = VK_NULL_HANDLE;
    fNumTextureSamplers = 0;
    fUniformBuffersToBind.fill({nullptr, 0});
    for (int i = 0; i < 4; ++i) {
        fCachedBlendConstant[i] = -1.0;
    }
    for (auto& boundInputBuffer : fBoundInputBuffers) {
        boundInputBuffer = VK_NULL_HANDLE;
    }
    for (auto& boundInputOffset : fBoundInputBufferOffsets) {
        boundInputOffset = 0;
    }
}

◆ onSynchronizeBufferToCpu()

bool skgpu::graphite::VulkanCommandBuffer::onSynchronizeBufferToCpu	(	const Buffer *	buffer,
		bool *	outDidResultInWork
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 1471 of file VulkanCommandBuffer.cpp.

                                                                                                 {
    static_cast<const VulkanBuffer*>(buffer)->setBufferAccess(this,
                                                              VK_ACCESS_HOST_READ_BIT,
                                                              VK_PIPELINE_STAGE_HOST_BIT);
 
    *outDidResultInWork = true;
    return true;
}

◆ prepareSurfaceForStateUpdate()

void skgpu::graphite::VulkanCommandBuffer::prepareSurfaceForStateUpdate	(	SkSurface *	targetSurface,
		const MutableTextureState *	newState
	)

overrideprivatevirtual

Reimplemented from skgpu::graphite::CommandBuffer.

Definition at line 209 of file VulkanCommandBuffer.cpp.

                                                                                            {
    TextureProxy* textureProxy = static_cast<Surface*>(targetSurface)->backingTextureProxy();
    VulkanTexture* texture = static_cast<VulkanTexture*>(textureProxy->texture());
 
    // Even though internally we use this helper for getting src access flags and stages they
    // can also be used for general dst flags since we don't know exactly what the client
    // plans on using the image for.
    VkImageLayout newLayout = skgpu::MutableTextureStates::GetVkImageLayout(newState);
    if (newLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
        newLayout = texture->currentLayout();
    }
    VkPipelineStageFlags dstStage = VulkanTexture::LayoutToPipelineSrcStageFlags(newLayout);
    VkAccessFlags dstAccess = VulkanTexture::LayoutToSrcAccessMask(newLayout);
 
    uint32_t currentQueueFamilyIndex = texture->currentQueueFamilyIndex();
    uint32_t newQueueFamilyIndex = skgpu::MutableTextureStates::GetVkQueueFamilyIndex(newState);
    auto isSpecialQueue = [](uint32_t queueFamilyIndex) {
        return queueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL ||
               queueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT;
    };
    if (isSpecialQueue(currentQueueFamilyIndex) && isSpecialQueue(newQueueFamilyIndex)) {
        // It is illegal to have both the new and old queue be special queue families (i.e. external
        // or foreign).
        return;
    }
 
    texture->setImageLayoutAndQueueIndex(this,
                                         newLayout,
                                         dstAccess,
                                         dstStage,
                                         false,
                                         newQueueFamilyIndex);
}

◆ setNewCommandBufferResources()

bool skgpu::graphite::VulkanCommandBuffer::setNewCommandBufferResources ( )

overridevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 149 of file VulkanCommandBuffer.cpp.

                                                       {
    this->begin();
    return true;
}

◆ submit()

bool skgpu::graphite::VulkanCommandBuffer::submit ( VkQueue queue )

Definition at line 279 of file VulkanCommandBuffer.cpp.

                                              {
    this->end();
 
    auto device = fSharedContext->device();
    VkResult err;
 
    if (fSubmitFence == VK_NULL_HANDLE) {
        VkFenceCreateInfo fenceInfo;
        memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        VULKAN_CALL_RESULT(
                fSharedContext, err, CreateFence(device, &fenceInfo, nullptr, &fSubmitFence));
        if (err) {
            fSubmitFence = VK_NULL_HANDLE;
            return false;
        }
    } else {
        // This cannot return DEVICE_LOST so we assert we succeeded.
        VULKAN_CALL_RESULT(fSharedContext, err, ResetFences(device, 1, &fSubmitFence));
        SkASSERT(err == VK_SUCCESS);
    }
 
    SkASSERT(fSubmitFence != VK_NULL_HANDLE);
    int waitCount = fWaitSemaphores.size();
    TArray<VkPipelineStageFlags> vkWaitStages(waitCount);
    for (int i = 0; i < waitCount; ++i) {
        vkWaitStages.push_back(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
                               VK_PIPELINE_STAGE_TRANSFER_BIT);
    }
 
    bool submitted = submit_to_queue(fSharedContext,
                                     queue,
                                     fSubmitFence,
                                     waitCount,
                                     fWaitSemaphores.data(),
                                     vkWaitStages.data(),
                                     /*commandBufferCount*/ 1,
                                     &fPrimaryCommandBuffer,
                                     fSignalSemaphores.size(),
                                     fSignalSemaphores.data(),
                                     fSharedContext->isProtected());
    fWaitSemaphores.clear();
    fSignalSemaphores.clear();
    if (!submitted) {
        // Destroy the fence or else we will try to wait forever for it to finish.
        VULKAN_CALL(fSharedContext->interface(), DestroyFence(device, fSubmitFence, nullptr));
        fSubmitFence = VK_NULL_HANDLE;
        return false;
    }
    return true;
}

◆ waitUntilFinished()

void skgpu::graphite::VulkanCommandBuffer::waitUntilFinished ( )

Definition at line 355 of file VulkanCommandBuffer.cpp.

                                            {
    if (fSubmitFence == VK_NULL_HANDLE) {
        return;
    }
    VULKAN_CALL_ERRCHECK(fSharedContext,
                         WaitForFences(fSharedContext->device(),
                                       1,
                                       &fSubmitFence,
                                       /*waitAll=*/true,
                                       /*timeout=*/UINT64_MAX));
}

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

third_party/skia/src/gpu/graphite/vk/VulkanCommandBuffer.h
third_party/skia/src/gpu/graphite/vk/VulkanCommandBuffer.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~VulkanCommandBuffer()

Member Function Documentation

◆ addBufferMemoryBarrier() [1/2]

◆ addBufferMemoryBarrier() [2/2]

◆ addImageMemoryBarrier()

◆ addSignalSemaphores()

◆ addWaitSemaphores()

◆ isFinished()

◆ Make()

◆ onAddComputePass()

◆ onAddRenderPass()

◆ onClearBuffer()

◆ onCopyBufferToBuffer()

◆ onCopyBufferToTexture()

◆ onCopyTextureToBuffer()

◆ onCopyTextureToTexture()

◆ onResetCommandBuffer()

◆ onSynchronizeBufferToCpu()

◆ prepareSurfaceForStateUpdate()

◆ setNewCommandBufferResources()

◆ submit()

◆ waitUntilFinished()