#include <GrVkCommandBuffer.h>

Inheritance diagram for GrVkCommandBuffer:

Public Types
enum	BarrierType { kBufferMemory_BarrierType , kImageMemory_BarrierType }

Public Member Functions
virtual	~GrVkCommandBuffer ()

void	invalidateState ()

void	pipelineBarrier (const GrVkGpu gpu, const GrManagedResource resource, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, BarrierType barrierType, void *barrier)

void	bindInputBuffer (GrVkGpu *gpu, uint32_t binding, sk_sp< const GrBuffer > buffer)

void	bindIndexBuffer (GrVkGpu *gpu, sk_sp< const GrBuffer > buffer)

void	bindPipeline (const GrVkGpu *gpu, sk_sp< const GrVkPipeline > pipeline)

void	bindDescriptorSets (const GrVkGpu gpu, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet descriptorSets, uint32_t dynamicOffsetCount, const uint32_t *dynamicOffsets)

void	pushConstants (const GrVkGpu gpu, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void values)

void	setViewport (const GrVkGpu gpu, uint32_t firstViewport, uint32_t viewportCount, const VkViewport viewports)

void	setScissor (const GrVkGpu gpu, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D scissors)

void	setBlendConstants (const GrVkGpu *gpu, const float blendConstants[4])

void	clearAttachments (const GrVkGpu gpu, int numAttachments, const VkClearAttachment attachments, int numRects, const VkClearRect *clearRects)

void	drawIndexed (const GrVkGpu *gpu, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)

void	draw (const GrVkGpu *gpu, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)

void	drawIndirect (const GrVkGpu *gpu, sk_sp< const GrBuffer > indirectBuffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)

void	drawIndexedIndirect (const GrVkGpu *gpu, sk_sp< const GrBuffer > indirectBuffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)

void	addResource (sk_sp< const GrManagedResource > resource)

void	addResource (const GrManagedResource *resource)

void	addRecycledResource (gr_rp< const GrRecycledResource > resource)

void	addRecycledResource (const GrRecycledResource *resource)

void	addGrBuffer (sk_sp< const GrBuffer > buffer)

void	addGrSurface (sk_sp< const GrSurface > surface)

void	releaseResources ()

void	freeGPUData (const GrGpu *gpu, VkCommandPool pool) const

bool	hasWork () const

Protected Types
template<typename T >
using	TrackedResourceArray = skia_private::STArray< kInitialTrackedResourcesCount, T >

Protected Member Functions
	GrVkCommandBuffer (VkCommandBuffer cmdBuffer, bool isWrapped=false)

bool	isWrapped () const

void	addingWork (const GrVkGpu *gpu)

void	submitPipelineBarriers (const GrVkGpu *gpu, bool forSelfDependency=false)

virtual void	onReleaseResources ()

virtual void	onFreeGPUData (const GrVkGpu *gpu) const =0

Protected Attributes
TrackedResourceArray< sk_sp< const GrManagedResource > >	fTrackedResources

TrackedResourceArray< gr_rp< const GrRecycledResource > >	fTrackedRecycledResources

skia_private::STArray< 16, sk_sp< const GrBuffer > >	fTrackedGpuBuffers

skia_private::STArray< 16, gr_cb< const GrSurface > >	fTrackedGpuSurfaces

bool	fIsActive

bool	fHasWork = false

const GrVkRenderPass *	fActiveRenderPass = nullptr

VkCommandBuffer	fCmdBuffer

VkBuffer	fBoundInputBuffers [kMaxInputBuffers]

VkBuffer	fBoundIndexBuffer

VkViewport	fCachedViewport

VkRect2D	fCachedScissor

float	fCachedBlendConstant [4]

skia_private::STArray< 1, VkBufferMemoryBarrier >	fBufferBarriers

skia_private::STArray< 2, VkImageMemoryBarrier >	fImageBarriers

bool	fBarriersByRegion = false

VkPipelineStageFlags	fSrcStageMask = 0

VkPipelineStageFlags	fDstStageMask = 0

bool	fIsWrapped

Static Protected Attributes
static constexpr uint32_t	kMaxInputBuffers = 2

Detailed Description

Definition at line 25 of file GrVkCommandBuffer.h.

Member Typedef Documentation

◆ TrackedResourceArray

template<typename T >

using GrVkCommandBuffer::TrackedResourceArray = skia_private::STArray<kInitialTrackedResourcesCount, T>

protected

Definition at line 163 of file GrVkCommandBuffer.h.

Member Enumeration Documentation

◆ BarrierType

enum GrVkCommandBuffer::BarrierType

Enumerator
kBufferMemory_BarrierType
kImageMemory_BarrierType

Definition at line 34 of file GrVkCommandBuffer.h.

                     {
        kBufferMemory_BarrierType,
        kImageMemory_BarrierType
    };

Constructor & Destructor Documentation

◆ ~GrVkCommandBuffer()

virtual GrVkCommandBuffer::~GrVkCommandBuffer ( )

inlinevirtual

Definition at line 27 of file GrVkCommandBuffer.h.

27{}

◆ GrVkCommandBuffer()

GrVkCommandBuffer::GrVkCommandBuffer	(	VkCommandBuffer	cmdBuffer,
		bool	isWrapped = `false`
	)

inlineprotected

Definition at line 145 of file GrVkCommandBuffer.h.

            : fIsActive(isWrapped) // All wrapped command buffers start as active
            , fCmdBuffer(cmdBuffer)
            , fIsWrapped(isWrapped) {
        this->invalidateState();
    }

Member Function Documentation

◆ addGrBuffer()

void GrVkCommandBuffer::addGrBuffer ( sk_sp< const GrBuffer > buffer )

inline

Definition at line 130 of file GrVkCommandBuffer.h.

                                                   {
        fTrackedGpuBuffers.push_back(std::move(buffer));
    }

◆ addGrSurface()

void GrVkCommandBuffer::addGrSurface ( sk_sp< const GrSurface > surface )

inline

Definition at line 134 of file GrVkCommandBuffer.h.

                                                      {
        fTrackedGpuSurfaces.push_back(std::move(surface));
    }

◆ addingWork()

void GrVkCommandBuffer::addingWork ( const GrVkGpu * gpu )

protected

Definition at line 402 of file GrVkCommandBuffer.cpp.

                                                     {
    this->submitPipelineBarriers(gpu);
    fHasWork = true;
}

◆ addRecycledResource() [1/2]

void GrVkCommandBuffer::addRecycledResource ( const GrRecycledResource * resource )

inline

Definition at line 126 of file GrVkCommandBuffer.h.

                                                                 {
        this->addRecycledResource(gr_ref_rp<const GrRecycledResource>(resource));
    }

◆ addRecycledResource() [2/2]

void GrVkCommandBuffer::addRecycledResource ( gr_rp< const GrRecycledResource > resource )

inline

Definition at line 121 of file GrVkCommandBuffer.h.

                                                                       {
        SkASSERT(resource);
        fTrackedRecycledResources.push_back(std::move(resource));
    }

◆ addResource() [1/2]

void GrVkCommandBuffer::addResource ( const GrManagedResource * resource )

inline

Definition at line 115 of file GrVkCommandBuffer.h.

                                                        {
        this->addResource(sk_ref_sp(resource));
    }

◆ addResource() [2/2]

void GrVkCommandBuffer::addResource ( sk_sp< const GrManagedResource > resource )

inline

Definition at line 111 of file GrVkCommandBuffer.h.

                                                              {
        SkASSERT(resource);
        fTrackedResources.push_back(std::move(resource));
    }

◆ bindDescriptorSets()

void GrVkCommandBuffer::bindDescriptorSets	(	const GrVkGpu *	gpu,
		VkPipelineLayout	layout,
		uint32_t	firstSet,
		uint32_t	setCount,
		const VkDescriptorSet *	descriptorSets,
		uint32_t	dynamicOffsetCount,
		const uint32_t *	dynamicOffsets
	)

Definition at line 254 of file GrVkCommandBuffer.cpp.

                                                                           {
    SkASSERT(fIsActive);
    GR_VK_CALL(gpu->vkInterface(), CmdBindDescriptorSets(fCmdBuffer,
                                                         VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                         layout,
                                                         firstSet,
                                                         setCount,
                                                         descriptorSets,
                                                         dynamicOffsetCount,
                                                         dynamicOffsets));
}

◆ bindIndexBuffer()

void GrVkCommandBuffer::bindIndexBuffer	(	GrVkGpu *	gpu,
		sk_sp< const GrBuffer >	buffer
	)

Definition at line 209 of file GrVkCommandBuffer.cpp.

                                                                                  {
    VkBuffer vkBuffer = static_cast<const GrVkBuffer*>(buffer.get())->vkBuffer();
    SkASSERT(VK_NULL_HANDLE != vkBuffer);
    // TODO: once ibuffer->offset() no longer always returns 0, we will need to track the offset
    // to know if we can skip binding or not.
    if (vkBuffer != fBoundIndexBuffer) {
        GR_VK_CALL(gpu->vkInterface(), CmdBindIndexBuffer(fCmdBuffer,
                                                          vkBuffer, /*offset=*/0,
                                                          VK_INDEX_TYPE_UINT16));
        fBoundIndexBuffer = vkBuffer;
        this->addGrBuffer(std::move(buffer));
    }
}

◆ bindInputBuffer()

void GrVkCommandBuffer::bindInputBuffer	(	GrVkGpu *	gpu,
		uint32_t	binding,
		sk_sp< const GrBuffer >	buffer
	)

Definition at line 190 of file GrVkCommandBuffer.cpp.

                                                                      {
    VkBuffer vkBuffer = static_cast<const GrVkBuffer*>(buffer.get())->vkBuffer();
    SkASSERT(VK_NULL_HANDLE != vkBuffer);
    SkASSERT(binding < kMaxInputBuffers);
    // TODO: once vbuffer->offset() no longer always returns 0, we will need to track the offset
    // to know if we can skip binding or not.
    if (vkBuffer != fBoundInputBuffers[binding]) {
        VkDeviceSize offset = 0;
        GR_VK_CALL(gpu->vkInterface(), CmdBindVertexBuffers(fCmdBuffer,
                                                            binding,
                                                            1,
                                                            &vkBuffer,
                                                            &offset));
        fBoundInputBuffers[binding] = vkBuffer;
        this->addGrBuffer(std::move(buffer));
    }
}

◆ bindPipeline()

void GrVkCommandBuffer::bindPipeline	(	const GrVkGpu *	gpu,
		sk_sp< const GrVkPipeline >	pipeline
	)

Definition at line 272 of file GrVkCommandBuffer.cpp.

                                                                                           {
    SkASSERT(fIsActive);
    GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
                                                   VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                   pipeline->pipeline()));
    this->addResource(std::move(pipeline));
}

◆ clearAttachments()

void GrVkCommandBuffer::clearAttachments	(	const GrVkGpu *	gpu,
		int	numAttachments,
		const VkClearAttachment *	attachments,
		int	numRects,
		const VkClearRect *	clearRects
	)

Definition at line 223 of file GrVkCommandBuffer.cpp.

                                                                        {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    SkASSERT(numAttachments > 0);
    SkASSERT(numRects > 0);
 
    this->addingWork(gpu);
 
#ifdef SK_DEBUG
    for (int i = 0; i < numAttachments; ++i) {
        if (attachments[i].aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) {
            uint32_t testIndex;
            SkAssertResult(fActiveRenderPass->colorAttachmentIndex(&testIndex));
            SkASSERT(testIndex == attachments[i].colorAttachment);
        }
    }
#endif
    GR_VK_CALL(gpu->vkInterface(), CmdClearAttachments(fCmdBuffer,
                                                       numAttachments,
                                                       attachments,
                                                       numRects,
                                                       clearRects));
    if (gpu->vkCaps().mustInvalidatePrimaryCmdBufferStateAfterClearAttachments()) {
        this->invalidateState();
    }
}

◆ draw()

void GrVkCommandBuffer::draw	(	const GrVkGpu *	gpu,
		uint32_t	vertexCount,
		uint32_t	instanceCount,
		uint32_t	firstVertex,
		uint32_t	firstInstance
	)

Definition at line 312 of file GrVkCommandBuffer.cpp.

                                                     {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    this->addingWork(gpu);
    GR_VK_CALL(gpu->vkInterface(), CmdDraw(fCmdBuffer,
                                           vertexCount,
                                           instanceCount,
                                           firstVertex,
                                           firstInstance));
}

◆ drawIndexed()

void GrVkCommandBuffer::drawIndexed	(	const GrVkGpu *	gpu,
		uint32_t	indexCount,
		uint32_t	instanceCount,
		uint32_t	firstIndex,
		int32_t	vertexOffset,
		uint32_t	firstInstance
	)

Definition at line 295 of file GrVkCommandBuffer.cpp.

                                                            {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    this->addingWork(gpu);
    GR_VK_CALL(gpu->vkInterface(), CmdDrawIndexed(fCmdBuffer,
                                                  indexCount,
                                                  instanceCount,
                                                  firstIndex,
                                                  vertexOffset,
                                                  firstInstance));
}

◆ drawIndexedIndirect()

void GrVkCommandBuffer::drawIndexedIndirect	(	const GrVkGpu *	gpu,
		sk_sp< const GrBuffer >	indirectBuffer,
		VkDeviceSize	offset,
		uint32_t	drawCount,
		uint32_t	stride
	)

Definition at line 345 of file GrVkCommandBuffer.cpp.

                                                             {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    SkASSERT(!indirectBuffer->isCpuBuffer());
    this->addingWork(gpu);
    VkBuffer vkBuffer = static_cast<const GrVkBuffer*>(indirectBuffer.get())->vkBuffer();
    GR_VK_CALL(gpu->vkInterface(), CmdDrawIndexedIndirect(fCmdBuffer,
                                                          vkBuffer,
                                                          offset,
                                                          drawCount,
                                                          stride));
    this->addGrBuffer(std::move(indirectBuffer));
}

◆ drawIndirect()

void GrVkCommandBuffer::drawIndirect	(	const GrVkGpu *	gpu,
		sk_sp< const GrBuffer >	indirectBuffer,
		VkDeviceSize	offset,
		uint32_t	drawCount,
		uint32_t	stride
	)

Definition at line 327 of file GrVkCommandBuffer.cpp.

                                                      {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    SkASSERT(!indirectBuffer->isCpuBuffer());
    this->addingWork(gpu);
    VkBuffer vkBuffer = static_cast<const GrVkBuffer*>(indirectBuffer.get())->vkBuffer();
    GR_VK_CALL(gpu->vkInterface(), CmdDrawIndirect(fCmdBuffer,
                                                   vkBuffer,
                                                   offset,
                                                   drawCount,
                                                   stride));
    this->addGrBuffer(std::move(indirectBuffer));
}

◆ freeGPUData()

void GrVkCommandBuffer::freeGPUData	(	const GrGpu *	gpu,
		VkCommandPool	pool
	)		const

Definition at line 43 of file GrVkCommandBuffer.cpp.

                                                                                 {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(!fIsActive);
    SkASSERT(fTrackedResources.empty());
    SkASSERT(fTrackedRecycledResources.empty());
    SkASSERT(fTrackedGpuBuffers.empty());
    SkASSERT(fTrackedGpuSurfaces.empty());
    SkASSERT(cmdPool != VK_NULL_HANDLE);
    SkASSERT(!this->isWrapped());
 
    const GrVkGpu* vkGpu = (const GrVkGpu*)gpu;
    GR_VK_CALL(vkGpu->vkInterface(), FreeCommandBuffers(vkGpu->device(), cmdPool, 1, &fCmdBuffer));
 
    this->onFreeGPUData(vkGpu);
}

◆ hasWork()

bool GrVkCommandBuffer::hasWork ( ) const

inline

Definition at line 142 of file GrVkCommandBuffer.h.

142{ return fHasWork; }

◆ invalidateState()

void GrVkCommandBuffer::invalidateState ( )

Definition at line 26 of file GrVkCommandBuffer.cpp.

                                        {
    for (auto& boundInputBuffer : fBoundInputBuffers) {
        boundInputBuffer = VK_NULL_HANDLE;
    }
    fBoundIndexBuffer = VK_NULL_HANDLE;
 
    memset(&fCachedViewport, 0, sizeof(VkViewport));
    fCachedViewport.width = - 1.0f; // Viewport must have a width greater than 0
 
    memset(&fCachedScissor, 0, sizeof(VkRect2D));
    fCachedScissor.offset.x = -1; // Scissor offset must be greater that 0 to be valid
 
    for (int i = 0; i < 4; ++i) {
        fCachedBlendConstant[i] = -1.0;
    }
}

◆ isWrapped()

bool GrVkCommandBuffer::isWrapped ( ) const

inlineprotected

Definition at line 152 of file GrVkCommandBuffer.h.

152{ return fIsWrapped; }

◆ onFreeGPUData()

virtual void GrVkCommandBuffer::onFreeGPUData ( const GrVkGpu * gpu ) const

protectedpure virtual

Implemented in GrVkPrimaryCommandBuffer, and GrVkSecondaryCommandBuffer.

◆ onReleaseResources()

virtual void GrVkCommandBuffer::onReleaseResources ( )

inlineprotectedvirtual

Reimplemented in GrVkPrimaryCommandBuffer.

Definition at line 181 of file GrVkCommandBuffer.h.

181{}

◆ pipelineBarrier()

void GrVkCommandBuffer::pipelineBarrier	(	const GrVkGpu *	gpu,
		const GrManagedResource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		BarrierType	barrierType,
		void *	barrier
	)

Definition at line 77 of file GrVkCommandBuffer.cpp.

                                                       {
    SkASSERT(!this->isWrapped());
    SkASSERT(fIsActive);
#ifdef SK_DEBUG
    // For images we can have barriers inside of render passes but they require us to add more
    // support in subpasses which need self dependencies to have barriers inside them. Also, we can
    // never have buffer barriers inside of a render pass. For now we will just assert that we are
    // not in a render pass.
    bool isValidSubpassBarrier = false;
    if (barrierType == kImageMemory_BarrierType) {
        VkImageMemoryBarrier* imgBarrier = static_cast<VkImageMemoryBarrier*>(barrier);
        isValidSubpassBarrier = (imgBarrier->newLayout == imgBarrier->oldLayout) &&
                                (imgBarrier->srcQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED) &&
                                (imgBarrier->dstQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED) &&
                                byRegion;
    }
    SkASSERT(!fActiveRenderPass || isValidSubpassBarrier);
#endif
 
    if (barrierType == kBufferMemory_BarrierType) {
        const VkBufferMemoryBarrier* barrierPtr = static_cast<VkBufferMemoryBarrier*>(barrier);
        fBufferBarriers.push_back(*barrierPtr);
    } else {
        SkASSERT(barrierType == kImageMemory_BarrierType);
        const VkImageMemoryBarrier* barrierPtr = static_cast<VkImageMemoryBarrier*>(barrier);
        // We need to check if we are adding a pipeline barrier that covers part of the same
        // subresource range as a barrier that is already in current batch. If it does, then we must
        // submit the first batch because the vulkan spec does not define a specific ordering for
        // barriers submitted in the same batch.
        // TODO: Look if we can gain anything by merging barriers together instead of submitting
        // the old ones.
        for (int i = 0; i < fImageBarriers.size(); ++i) {
            VkImageMemoryBarrier& currentBarrier = fImageBarriers[i];
            if (barrierPtr->image == currentBarrier.image) {
                const VkImageSubresourceRange newRange = barrierPtr->subresourceRange;
                const VkImageSubresourceRange oldRange = currentBarrier.subresourceRange;
                SkASSERT(newRange.aspectMask == oldRange.aspectMask);
                SkASSERT(newRange.baseArrayLayer == oldRange.baseArrayLayer);
                SkASSERT(newRange.layerCount == oldRange.layerCount);
                uint32_t newStart = newRange.baseMipLevel;
                uint32_t newEnd = newRange.baseMipLevel + newRange.levelCount - 1;
                uint32_t oldStart = oldRange.baseMipLevel;
                uint32_t oldEnd = oldRange.baseMipLevel + oldRange.levelCount - 1;
                if (std::max(newStart, oldStart) <= std::min(newEnd, oldEnd)) {
                    this->submitPipelineBarriers(gpu);
                    break;
                }
            }
        }
        fImageBarriers.push_back(*barrierPtr);
    }
    fBarriersByRegion |= byRegion;
    fSrcStageMask = fSrcStageMask | srcStageMask;
    fDstStageMask = fDstStageMask | dstStageMask;
 
    fHasWork = true;
    if (resource) {
        this->addResource(resource);
    }
    if (fActiveRenderPass) {
        this->submitPipelineBarriers(gpu, true);
    }
}

◆ pushConstants()

void GrVkCommandBuffer::pushConstants	(	const GrVkGpu *	gpu,
		VkPipelineLayout	layout,
		VkShaderStageFlags	stageFlags,
		uint32_t	offset,
		uint32_t	size,
		const void *	values
	)

Definition at line 280 of file GrVkCommandBuffer.cpp.

                                                          {
    SkASSERT(fIsActive);
    // offset and size must be a multiple of 4
    SkASSERT(!SkToBool(offset & 0x3));
    SkASSERT(!SkToBool(size & 0x3));
    GR_VK_CALL(gpu->vkInterface(), CmdPushConstants(fCmdBuffer,
                                                    layout,
                                                    stageFlags,
                                                    offset,
                                                    size,
                                                    values));
}

◆ releaseResources()

void GrVkCommandBuffer::releaseResources ( )

Definition at line 59 of file GrVkCommandBuffer.cpp.

                                         {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(!fIsActive || this->isWrapped());
    fTrackedResources.clear();
    fTrackedRecycledResources.clear();
 
    fTrackedGpuBuffers.clear();
    fTrackedGpuSurfaces.clear();
 
    this->invalidateState();
 
    this->onReleaseResources();
}

◆ setBlendConstants()

void GrVkCommandBuffer::setBlendConstants	(	const GrVkGpu *	gpu,
		const float	blendConstants[4]
	)

Definition at line 393 of file GrVkCommandBuffer.cpp.

                                                                         {
    SkASSERT(fIsActive);
    if (0 != memcmp(blendConstants, fCachedBlendConstant, 4 * sizeof(float))) {
        GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendConstants));
        memcpy(fCachedBlendConstant, blendConstants, 4 * sizeof(float));
    }
}

◆ setScissor()

void GrVkCommandBuffer::setScissor	(	const GrVkGpu *	gpu,
		uint32_t	firstScissor,
		uint32_t	scissorCount,
		const VkRect2D *	scissors
	)

Definition at line 378 of file GrVkCommandBuffer.cpp.

                                                             {
    SkASSERT(fIsActive);
    SkASSERT(1 == scissorCount);
    if (0 != memcmp(scissors, &fCachedScissor, sizeof(VkRect2D))) {
        GR_VK_CALL(gpu->vkInterface(), CmdSetScissor(fCmdBuffer,
                                                     firstScissor,
                                                     scissorCount,
                                                     scissors));
        fCachedScissor = scissors[0];
    }
}

◆ setViewport()

void GrVkCommandBuffer::setViewport	(	const GrVkGpu *	gpu,
		uint32_t	firstViewport,
		uint32_t	viewportCount,
		const VkViewport *	viewports
	)

Definition at line 363 of file GrVkCommandBuffer.cpp.

                                                                 {
    SkASSERT(fIsActive);
    SkASSERT(1 == viewportCount);
    if (0 != memcmp(viewports, &fCachedViewport, sizeof(VkViewport))) {
        GR_VK_CALL(gpu->vkInterface(), CmdSetViewport(fCmdBuffer,
                                                      firstViewport,
                                                      viewportCount,
                                                      viewports));
        fCachedViewport = viewports[0];
    }
}

◆ submitPipelineBarriers()

void GrVkCommandBuffer::submitPipelineBarriers	(	const GrVkGpu *	gpu,
		bool	forSelfDependency = `false`
	)

protected

Definition at line 147 of file GrVkCommandBuffer.cpp.

                                                                                         {
    SkASSERT(fIsActive);
 
    // Currently we never submit a pipeline barrier without at least one memory barrier.
    if (!fBufferBarriers.empty() || !fImageBarriers.empty()) {
        // For images we can have barriers inside of render passes but they require us to add more
        // support in subpasses which need self dependencies to have barriers inside them. Also, we
        // can never have buffer barriers inside of a render pass. For now we will just assert that
        // we are not in a render pass.
        SkASSERT(!fActiveRenderPass || forSelfDependency);
        SkASSERT(!this->isWrapped());
        SkASSERT(fSrcStageMask && fDstStageMask);
 
        // TODO(https://crbug.com/1469231): The linked bug references a crash report from calling
        // CmdPipelineBarrier. The checks below were added to ensure that we are passing in buffer
        // counts >= 0, and in the case of >0, that the buffers are non-null. Evaluate whether this
        // change leads to a reduction in crash instances. If not, the issue may lie within the
        // driver itself and these checks can be removed.
        if (!fBufferBarriers.empty() && fBufferBarriers.begin() == nullptr) {
            fBufferBarriers.clear(); // Sets the size to 0
        }
        if (!fImageBarriers.empty() && fImageBarriers.begin() == nullptr) {
            fImageBarriers.clear(); // Sets the size to 0
        }
 
        VkDependencyFlags dependencyFlags = fBarriersByRegion ? VK_DEPENDENCY_BY_REGION_BIT : 0;
        GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(
                fCmdBuffer, fSrcStageMask, fDstStageMask, dependencyFlags, 0, nullptr,
                fBufferBarriers.size(), fBufferBarriers.begin(),
                fImageBarriers.size(), fImageBarriers.begin()));
        fBufferBarriers.clear();
        fImageBarriers.clear();
        fBarriersByRegion = false;
        fSrcStageMask = 0;
        fDstStageMask = 0;
    }
    SkASSERT(fBufferBarriers.empty());
    SkASSERT(fImageBarriers.empty());
    SkASSERT(!fBarriersByRegion);
    SkASSERT(!fSrcStageMask);
    SkASSERT(!fDstStageMask);
}

Member Data Documentation

◆ fActiveRenderPass

const GrVkRenderPass* GrVkCommandBuffer::fActiveRenderPass = nullptr

protected

Definition at line 177 of file GrVkCommandBuffer.h.

◆ fBarriersByRegion

bool GrVkCommandBuffer::fBarriersByRegion = false

protected

Definition at line 197 of file GrVkCommandBuffer.h.

◆ fBoundIndexBuffer

VkBuffer GrVkCommandBuffer::fBoundIndexBuffer

protected

Definition at line 187 of file GrVkCommandBuffer.h.

◆ fBoundInputBuffers

VkBuffer GrVkCommandBuffer::fBoundInputBuffers[kMaxInputBuffers]

protected

Definition at line 186 of file GrVkCommandBuffer.h.

◆ fBufferBarriers

skia_private::STArray<1, VkBufferMemoryBarrier> GrVkCommandBuffer::fBufferBarriers

protected

Definition at line 195 of file GrVkCommandBuffer.h.

◆ fCachedBlendConstant

float GrVkCommandBuffer::fCachedBlendConstant[4]

protected

Definition at line 192 of file GrVkCommandBuffer.h.

◆ fCachedScissor

VkRect2D GrVkCommandBuffer::fCachedScissor

protected

Definition at line 191 of file GrVkCommandBuffer.h.

◆ fCachedViewport

VkViewport GrVkCommandBuffer::fCachedViewport

protected

Definition at line 190 of file GrVkCommandBuffer.h.

◆ fCmdBuffer

VkCommandBuffer GrVkCommandBuffer::fCmdBuffer

protected

Definition at line 179 of file GrVkCommandBuffer.h.

◆ fDstStageMask

VkPipelineStageFlags GrVkCommandBuffer::fDstStageMask = 0

protected

Definition at line 199 of file GrVkCommandBuffer.h.

◆ fHasWork

bool GrVkCommandBuffer::fHasWork = false

protected

Definition at line 172 of file GrVkCommandBuffer.h.

◆ fImageBarriers

skia_private::STArray<2, VkImageMemoryBarrier> GrVkCommandBuffer::fImageBarriers

protected

Definition at line 196 of file GrVkCommandBuffer.h.

◆ fIsActive

bool GrVkCommandBuffer::fIsActive

protected

Definition at line 171 of file GrVkCommandBuffer.h.

◆ fIsWrapped

bool GrVkCommandBuffer::fIsWrapped

protected

Definition at line 201 of file GrVkCommandBuffer.h.

◆ fSrcStageMask

VkPipelineStageFlags GrVkCommandBuffer::fSrcStageMask = 0

protected

Definition at line 198 of file GrVkCommandBuffer.h.

◆ fTrackedGpuBuffers

skia_private::STArray<16, sk_sp<const GrBuffer> > GrVkCommandBuffer::fTrackedGpuBuffers

protected

Definition at line 166 of file GrVkCommandBuffer.h.

◆ fTrackedGpuSurfaces

skia_private::STArray<16, gr_cb<const GrSurface> > GrVkCommandBuffer::fTrackedGpuSurfaces

protected

Definition at line 167 of file GrVkCommandBuffer.h.

◆ fTrackedRecycledResources

TrackedResourceArray<gr_rp<const GrRecycledResource> > GrVkCommandBuffer::fTrackedRecycledResources

protected

Definition at line 165 of file GrVkCommandBuffer.h.

◆ fTrackedResources

TrackedResourceArray<sk_sp<const GrManagedResource> > GrVkCommandBuffer::fTrackedResources

protected

Definition at line 164 of file GrVkCommandBuffer.h.

◆ kMaxInputBuffers

constexpr uint32_t GrVkCommandBuffer::kMaxInputBuffers = 2

staticconstexprprotected

Definition at line 184 of file GrVkCommandBuffer.h.

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

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ TrackedResourceArray

Member Enumeration Documentation

◆ BarrierType

Constructor & Destructor Documentation

◆ ~GrVkCommandBuffer()

◆ GrVkCommandBuffer()

Member Function Documentation

◆ addGrBuffer()

◆ addGrSurface()

◆ addingWork()

◆ addRecycledResource() [1/2]

◆ addRecycledResource() [2/2]

◆ addResource() [1/2]

◆ addResource() [2/2]

◆ bindDescriptorSets()

◆ bindIndexBuffer()

◆ bindInputBuffer()

◆ bindPipeline()

◆ clearAttachments()

◆ draw()

◆ drawIndexed()

◆ drawIndexedIndirect()

◆ drawIndirect()

◆ freeGPUData()

◆ hasWork()

◆ invalidateState()

◆ isWrapped()

◆ onFreeGPUData()

◆ onReleaseResources()

◆ pipelineBarrier()

◆ pushConstants()

◆ releaseResources()

◆ setBlendConstants()

◆ setScissor()

◆ setViewport()

◆ submitPipelineBarriers()

Member Data Documentation

◆ fActiveRenderPass

◆ fBarriersByRegion

◆ fBoundIndexBuffer

◆ fBoundInputBuffers

◆ fBufferBarriers

◆ fCachedBlendConstant

◆ fCachedScissor

◆ fCachedViewport

◆ fCmdBuffer

◆ fDstStageMask

◆ fHasWork

◆ fImageBarriers

◆ fIsActive

◆ fIsWrapped

◆ fSrcStageMask

◆ fTrackedGpuBuffers

◆ fTrackedGpuSurfaces

◆ fTrackedRecycledResources

◆ fTrackedResources

◆ kMaxInputBuffers