Skip to content

A
angle
Commit e18ff25d by Tobin Ehlis Committed by Commit Bot
Options

Vulkan:Refactor SecondaryCommandBuffers

A bunch of changes to rework and improve SecondaryCommandBuffers. Inlined all of the command functions and moved them into the header. Created new specialized commands for updating Compute/Graphics DescriptorSets and setting a memoryBarrier. Updated all of the pointer storage to be inferred rather than explicitly stored in order to save space. Also removed various params that are fixed in ANGLE to save space. Bug: angleproject:3136 Change-Id: I994bb70d5e4db6d9e71d38ac62451aaec780a5e1 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1535704Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Commit-Queue: Tobin Ehlis <tobine@google.com>
parent 5fd08af4
Showing with 617 additions and 665 deletions
src/libANGLE/renderer/vulkan/ContextVk.cpp
......@@ -436,9 +436,9 @@ angle::Result ContextVk::handleDirtyDescriptorSets(const gl::Context *context,
ANGLE_TRY(mProgram->updateDescriptorSets(this, commandBuffer));
// Bind the graphics descriptor sets.
commandBuffer->bindDescriptorSets(
VK_PIPELINE_BIND_POINT_GRAPHICS, mProgram->getPipelineLayout(),
kDriverUniformsDescriptorSetIndex, 1, &mDriverUniformsDescriptorSet, 0, nullptr);
commandBuffer->bindGraphicsDescriptorSets(mProgram->getPipelineLayout(),
kDriverUniformsDescriptorSetIndex, 1,
&mDriverUniformsDescriptorSet, 0, nullptr);
return angle::Result::Continue;
}
......
src/libANGLE/renderer/vulkan/ProgramVk.cpp
......@@ -927,16 +927,15 @@ angle::Result ProgramVk::updateDescriptorSets(ContextVk *contextVk,
{
constexpr uint32_t kShaderTypeMin = static_cast<uint32_t>(gl::kGLES2ShaderTypeMin);
constexpr uint32_t kShaderTypeMax = static_cast<uint32_t>(gl::kGLES2ShaderTypeMax);
commandBuffer->bindDescriptorSets(
VK_PIPELINE_BIND_POINT_GRAPHICS, mPipelineLayout.get(), low,
mUsedDescriptorSetRange.length(), &mDescriptorSets[low],
commandBuffer->bindGraphicsDescriptorSets(
mPipelineLayout.get(), low, mUsedDescriptorSetRange.length(), &mDescriptorSets[low],
kShaderTypeMax - kShaderTypeMin + 1, mUniformBlocksOffsets.data() + kShaderTypeMin);
}
else
{
commandBuffer->bindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, mPipelineLayout.get(),
low, mUsedDescriptorSetRange.length(),
&mDescriptorSets[low], 0, nullptr);
commandBuffer->bindGraphicsDescriptorSets(mPipelineLayout.get(), low,
mUsedDescriptorSetRange.length(),
&mDescriptorSets[low], 0, nullptr);
}
return angle::Result::Continue;
......
src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.cpp
......@@ -16,332 +16,6 @@ namespace vk
{
namespace priv
{
void SecondaryCommandBuffer::blitImage(const Image &srcImage,
VkImageLayout srcImageLayout,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit *pRegions,
VkFilter filter)
{
size_t regionSize = regionCount * sizeof(VkImageBlit);
BlitImageParams *paramStruct = initCommand<BlitImageParams>(CommandID::BlitImage, regionSize);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->srcImageLayout = srcImageLayout;
paramStruct->dstImage = dstImage.getHandle();
paramStruct->dstImageLayout = dstImageLayout;
paramStruct->regionCount = regionCount;
paramStruct->filter = filter;
// Copy variable sized data
storePointerParameter(pRegions, &paramStruct->pRegions, regionSize);
}
void SecondaryCommandBuffer::copyBuffer(const Buffer &srcBuffer,
const Buffer &destBuffer,
uint32_t regionCount,
const VkBufferCopy *regions)
{
size_t regionSize = regionCount * sizeof(VkBufferCopy);
CopyBufferParams *paramStruct =
initCommand<CopyBufferParams>(CommandID::CopyBuffer, regionSize);
paramStruct->srcBuffer = srcBuffer.getHandle();
paramStruct->destBuffer = destBuffer.getHandle();
paramStruct->regionCount = regionCount;
// Copy variable sized data
storePointerParameter(regions, &paramStruct->regions, regionSize);
}
void SecondaryCommandBuffer::copyBufferToImage(VkBuffer srcBuffer,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy *regions)
{
size_t regionSize = regionCount * sizeof(VkBufferImageCopy);
CopyBufferToImageParams *paramStruct =
initCommand<CopyBufferToImageParams>(CommandID::CopyBufferToImage, regionSize);
paramStruct->srcBuffer = srcBuffer;
paramStruct->dstImage = dstImage.getHandle();
paramStruct->dstImageLayout = dstImageLayout;
paramStruct->regionCount = regionCount;
// Copy variable sized data
storePointerParameter(regions, &paramStruct->regions, regionSize);
}
void SecondaryCommandBuffer::copyImage(const Image &srcImage,
VkImageLayout srcImageLayout,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy *regions)
{
size_t regionSize = regionCount * sizeof(VkImageCopy);
CopyImageParams *paramStruct = initCommand<CopyImageParams>(CommandID::CopyImage, regionSize);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->srcImageLayout = srcImageLayout;
paramStruct->dstImage = dstImage.getHandle();
paramStruct->dstImageLayout = dstImageLayout;
paramStruct->regionCount = regionCount;
// Copy variable sized data
storePointerParameter(regions, &paramStruct->regions, regionSize);
}
void SecondaryCommandBuffer::copyImageToBuffer(const Image &srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy *regions)
{
size_t regionSize = regionCount * sizeof(VkBufferImageCopy);
CopyImageToBufferParams *paramStruct =
initCommand<CopyImageToBufferParams>(CommandID::CopyImageToBuffer, regionSize);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->srcImageLayout = srcImageLayout;
paramStruct->dstBuffer = dstBuffer;
paramStruct->regionCount = regionCount;
// Copy variable sized data
storePointerParameter(regions, &paramStruct->regions, regionSize);
}
void SecondaryCommandBuffer::clearAttachments(uint32_t attachmentCount,
const VkClearAttachment *attachments,
uint32_t rectCount,
const VkClearRect *rects)
{
size_t attachSize = attachmentCount * sizeof(VkClearAttachment);
size_t rectSize = rectCount * sizeof(VkClearRect);
ClearAttachmentsParams *paramStruct =
initCommand<ClearAttachmentsParams>(CommandID::ClearAttachments, attachSize + rectSize);
paramStruct->attachmentCount = attachmentCount;
paramStruct->rectCount = rectCount;
// Copy variable sized data
storePointerParameter(attachments, &paramStruct->attachments, attachSize);
storePointerParameter(rects, &paramStruct->rects, rectSize);
}
void SecondaryCommandBuffer::clearColorImage(const Image &image,
VkImageLayout imageLayout,
const VkClearColorValue &color,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges)
{
size_t rangeSize = rangeCount * sizeof(VkImageSubresourceRange);
ClearColorImageParams *paramStruct =
initCommand<ClearColorImageParams>(CommandID::ClearColorImage, rangeSize);
paramStruct->image = image.getHandle();
paramStruct->imageLayout = imageLayout;
paramStruct->color = color;
paramStruct->rangeCount = rangeCount;
// Copy variable sized data
storePointerParameter(ranges, &paramStruct->ranges, rangeSize);
}
void SecondaryCommandBuffer::clearDepthStencilImage(const Image &image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue &depthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges)
{
size_t rangeSize = rangeCount * sizeof(VkImageSubresourceRange);
ClearDepthStencilImageParams *paramStruct =
initCommand<ClearDepthStencilImageParams>(CommandID::ClearDepthStencilImage, rangeSize);
paramStruct->image = image.getHandle();
paramStruct->imageLayout = imageLayout;
paramStruct->depthStencil = depthStencil;
paramStruct->rangeCount = rangeCount;
// Copy variable sized data
storePointerParameter(ranges, &paramStruct->ranges, rangeSize);
}
void SecondaryCommandBuffer::updateBuffer(const Buffer &buffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void *data)
{
ASSERT(dataSize == static_cast<size_t>(dataSize));
UpdateBufferParams *paramStruct =
initCommand<UpdateBufferParams>(CommandID::UpdateBuffer, static_cast<size_t>(dataSize));
paramStruct->buffer = buffer.getHandle();
paramStruct->dstOffset = dstOffset;
paramStruct->dataSize = dataSize;
// Copy variable sized data
storePointerParameter(data, &paramStruct->data, static_cast<size_t>(dataSize));
}
void SecondaryCommandBuffer::pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
uint32_t size,
const void *data)
{
ASSERT(size == static_cast<size_t>(size));
PushConstantsParams *paramStruct =
initCommand<PushConstantsParams>(CommandID::PushConstants, static_cast<size_t>(size));
paramStruct->layout = layout.getHandle();
paramStruct->flag = flag;
paramStruct->offset = offset;
paramStruct->size = size;
// Copy variable sized data
storePointerParameter(data, &paramStruct->data, static_cast<size_t>(size));
}
void SecondaryCommandBuffer::setViewport(uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport *viewports)
{
size_t viewportSize = viewportCount * sizeof(VkViewport);
SetViewportParams *paramStruct =
initCommand<SetViewportParams>(CommandID::SetViewport, viewportSize);
paramStruct->firstViewport = firstViewport;
paramStruct->viewportCount = viewportCount;
// Copy variable sized data
storePointerParameter(viewports, &paramStruct->viewports, viewportSize);
}
void SecondaryCommandBuffer::setScissor(uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D *scissors)
{
size_t scissorSize = scissorCount * sizeof(VkRect2D);
SetScissorParams *paramStruct =
initCommand<SetScissorParams>(CommandID::SetScissor, scissorSize);
paramStruct->firstScissor = firstScissor;
paramStruct->scissorCount = scissorCount;
// Copy variable sized data
storePointerParameter(scissors, &paramStruct->scissors, scissorSize);
}
void SecondaryCommandBuffer::dispatch(uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ)
{
DispatchParams *paramStruct = initCommand<DispatchParams>(CommandID::Dispatch);
paramStruct->groupCountX = groupCountX;
paramStruct->groupCountY = groupCountY;
paramStruct->groupCountZ = groupCountZ;
}
void SecondaryCommandBuffer::pipelineBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers)
{
size_t memBarrierSize = memoryBarrierCount * sizeof(VkMemoryBarrier);
size_t buffBarrierSize = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
size_t imgBarrierSize = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
PipelineBarrierParams *paramStruct = initCommand<PipelineBarrierParams>(
CommandID::PipelineBarrier, memBarrierSize + buffBarrierSize + imgBarrierSize);
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->dependencyFlags = dependencyFlags;
paramStruct->memoryBarrierCount = memoryBarrierCount;
paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
paramStruct->imageMemoryBarrierCount = imageMemoryBarrierCount;
// Copy variable sized data
storePointerParameter(memoryBarriers, &paramStruct->memoryBarriers, memBarrierSize);
storePointerParameter(bufferMemoryBarriers, &paramStruct->bufferMemoryBarriers,
buffBarrierSize);
storePointerParameter(imageMemoryBarriers, &paramStruct->imageMemoryBarriers, imgBarrierSize);
}
void SecondaryCommandBuffer::imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkImageMemoryBarrier *imageMemoryBarrier)
{
ImageBarrierParams *paramStruct = initCommand<ImageBarrierParams>(CommandID::ImageBarrier);
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->imageMemoryBarrier = *imageMemoryBarrier;
}
void SecondaryCommandBuffer::setEvent(VkEvent event, VkPipelineStageFlags stageMask)
{
SetEventParams *paramStruct = initCommand<SetEventParams>(CommandID::SetEvent);
paramStruct->event = event;
paramStruct->stageMask = stageMask;
}
void SecondaryCommandBuffer::resetEvent(VkEvent event, VkPipelineStageFlags stageMask)
{
ResetEventParams *paramStruct = initCommand<ResetEventParams>(CommandID::ResetEvent);
paramStruct->event = event;
paramStruct->stageMask = stageMask;
}
void SecondaryCommandBuffer::waitEvents(uint32_t eventCount,
const VkEvent *events,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers)
{
size_t eventSize = eventCount * sizeof(VkEvent);
size_t memBarrierSize = memoryBarrierCount * sizeof(VkMemoryBarrier);
size_t buffBarrierSize = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
size_t imgBarrierSize = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
WaitEventsParams *paramStruct = initCommand<WaitEventsParams>(
CommandID::WaitEvents, eventSize + memBarrierSize + buffBarrierSize + imgBarrierSize);
paramStruct->eventCount = eventCount;
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->memoryBarrierCount = memoryBarrierCount;
paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
paramStruct->imageMemoryBarrierCount = imageMemoryBarrierCount;
// Copy variable sized data
storePointerParameter(events, &paramStruct->events, eventSize);
storePointerParameter(memoryBarriers, &paramStruct->memoryBarriers, memBarrierSize);
storePointerParameter(bufferMemoryBarriers, &paramStruct->bufferMemoryBarriers,
buffBarrierSize);
storePointerParameter(imageMemoryBarriers, &paramStruct->imageMemoryBarriers, imgBarrierSize);
}
void SecondaryCommandBuffer::resetQueryPool(VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount)
{
ResetQueryPoolParams *paramStruct =
initCommand<ResetQueryPoolParams>(CommandID::ResetQueryPool);
paramStruct->queryPool = queryPool;
paramStruct->firstQuery = firstQuery;
paramStruct->queryCount = queryCount;
}
void SecondaryCommandBuffer::beginQuery(VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags)
{
BeginQueryParams *paramStruct = initCommand<BeginQueryParams>(CommandID::BeginQuery);
paramStruct->queryPool = queryPool;
paramStruct->query = query;
paramStruct->flags = flags;
}
void SecondaryCommandBuffer::endQuery(VkQueryPool queryPool, uint32_t query)
{
EndQueryParams *paramStruct = initCommand<EndQueryParams>(CommandID::EndQuery);
paramStruct->queryPool = queryPool;
paramStruct->query = query;
}
void SecondaryCommandBuffer::writeTimestamp(VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query)
{
WriteTimestampParams *paramStruct =
initCommand<WriteTimestampParams>(CommandID::WriteTimestamp);
paramStruct->pipelineStage = pipelineStage;
paramStruct->queryPool = queryPool;
paramStruct->query = query;
}
ANGLE_INLINE const CommandHeader *NextCommand(const CommandHeader *command)
{
......@@ -365,6 +39,16 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
vkCmdBeginQuery(cmdBuffer, params->queryPool, params->query, params->flags);
break;
}
case CommandID::BindComputeDescriptorSets:
{
const BindComputeDescriptorSetParams *params =
getParamPtr<BindComputeDescriptorSetParams>(currentCommand);
const VkDescriptorSet *descriptorSets =
Offset<VkDescriptorSet>(params, sizeof(BindComputeDescriptorSetParams));
vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE,
params->layout, 0, 1, descriptorSets, 0, nullptr);
break;
}
case CommandID::BindComputePipeline:
{
const BindPipelineParams *params =
......@@ -372,14 +56,18 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, params->pipeline);
break;
}
case CommandID::BindDescriptorSets:
case CommandID::BindGraphicsDescriptorSets:
{
const BindDescriptorSetParams *params =
getParamPtr<BindDescriptorSetParams>(currentCommand);
vkCmdBindDescriptorSets(cmdBuffer, params->bindPoint, params->layout,
params->firstSet, params->descriptorSetCount,
params->descriptorSets, params->dynamicOffsetCount,
params->dynamicOffsets);
const BindGraphicsDescriptorSetParams *params =
getParamPtr<BindGraphicsDescriptorSetParams>(currentCommand);
const VkDescriptorSet *descriptorSets =
Offset<VkDescriptorSet>(params, sizeof(BindGraphicsDescriptorSetParams));
const uint32_t *dynamicOffsets = Offset<uint32_t>(
descriptorSets, sizeof(VkDescriptorSet) * params->descriptorSetCount);
vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
params->layout, params->firstSet,
params->descriptorSetCount, descriptorSets,
params->dynamicOffsetCount, dynamicOffsets);
break;
}
case CommandID::BindGraphicsPipeline:
......@@ -411,17 +99,20 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
case CommandID::BlitImage:
{
const BlitImageParams *params = getParamPtr<BlitImageParams>(currentCommand);
vkCmdBlitImage(cmdBuffer, params->srcImage, params->srcImageLayout,
params->dstImage, params->dstImageLayout, params->regionCount,
params->pRegions, params->filter);
vkCmdBlitImage(cmdBuffer, params->srcImage,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, params->dstImage,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &params->region,
params->filter);
break;
}
case CommandID::ClearAttachments:
{
const ClearAttachmentsParams *params =
getParamPtr<ClearAttachmentsParams>(currentCommand);
vkCmdClearAttachments(cmdBuffer, params->attachmentCount, params->attachments,
params->rectCount, params->rects);
const VkClearAttachment *attachments =
Offset<VkClearAttachment>(params, sizeof(ClearAttachmentsParams));
vkCmdClearAttachments(cmdBuffer, params->attachmentCount, attachments, 1,
&params->rect);
break;
}
case CommandID::ClearColorImage:
......@@ -429,7 +120,7 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
const ClearColorImageParams *params =
getParamPtr<ClearColorImageParams>(currentCommand);
vkCmdClearColorImage(cmdBuffer, params->image, params->imageLayout,
&params->color, params->rangeCount, params->ranges);
&params->color, 1, &params->range);
break;
}
case CommandID::ClearDepthStencilImage:
......@@ -437,15 +128,16 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
const ClearDepthStencilImageParams *params =
getParamPtr<ClearDepthStencilImageParams>(currentCommand);
vkCmdClearDepthStencilImage(cmdBuffer, params->image, params->imageLayout,
&params->depthStencil, params->rangeCount,
params->ranges);
&params->depthStencil, 1, &params->range);
break;
}
case CommandID::CopyBuffer:
{
const CopyBufferParams *params = getParamPtr<CopyBufferParams>(currentCommand);
const VkBufferCopy *regions =
Offset<VkBufferCopy>(params, sizeof(CopyBufferParams));
vkCmdCopyBuffer(cmdBuffer, params->srcBuffer, params->destBuffer,
params->regionCount, params->regions);
params->regionCount, regions);
break;
}
case CommandID::CopyBufferToImage:
......@@ -453,16 +145,14 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
const CopyBufferToImageParams *params =
getParamPtr<CopyBufferToImageParams>(currentCommand);
vkCmdCopyBufferToImage(cmdBuffer, params->srcBuffer, params->dstImage,
params->dstImageLayout, params->regionCount,
params->regions);
params->dstImageLayout, 1, &params->region);
break;
}
case CommandID::CopyImage:
{
const CopyImageParams *params = getParamPtr<CopyImageParams>(currentCommand);
vkCmdCopyImage(cmdBuffer, params->srcImage, params->srcImageLayout,
params->dstImage, params->dstImageLayout, params->regionCount,
params->regions);
params->dstImage, params->dstImageLayout, 1, &params->region);
break;
}
case CommandID::CopyImageToBuffer:
......@@ -470,7 +160,7 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
const CopyImageToBufferParams *params =
getParamPtr<CopyImageToBufferParams>(currentCommand);
vkCmdCopyImageToBuffer(cmdBuffer, params->srcImage, params->srcImageLayout,
params->dstBuffer, params->regionCount, params->regions);
params->dstBuffer, 1, &params->region);
break;
}
case CommandID::Dispatch:
......@@ -522,23 +212,40 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
0, nullptr, 0, nullptr, 1, &params->imageMemoryBarrier);
break;
}
case CommandID::MemoryBarrier:
{
const MemoryBarrierParams *params =
getParamPtr<MemoryBarrierParams>(currentCommand);
vkCmdPipelineBarrier(cmdBuffer, params->srcStageMask, params->dstStageMask, 0,
1, &params->memoryBarrier, 0, nullptr, 0, nullptr);
break;
}
case CommandID::PipelineBarrier:
{
const PipelineBarrierParams *params =
getParamPtr<PipelineBarrierParams>(currentCommand);
vkCmdPipelineBarrier(
cmdBuffer, params->srcStageMask, params->dstStageMask,
params->dependencyFlags, params->memoryBarrierCount, params->memoryBarriers,
params->bufferMemoryBarrierCount, params->bufferMemoryBarriers,
params->imageMemoryBarrierCount, params->imageMemoryBarriers);
const VkMemoryBarrier *memoryBarriers =
Offset<VkMemoryBarrier>(params, sizeof(PipelineBarrierParams));
const VkBufferMemoryBarrier *bufferMemoryBarriers =
Offset<VkBufferMemoryBarrier>(
memoryBarriers, params->memoryBarrierCount * sizeof(VkMemoryBarrier));
const VkImageMemoryBarrier *imageMemoryBarriers = Offset<VkImageMemoryBarrier>(
bufferMemoryBarriers,
params->bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier));
vkCmdPipelineBarrier(cmdBuffer, params->srcStageMask, params->dstStageMask,
params->dependencyFlags, params->memoryBarrierCount,
memoryBarriers, params->bufferMemoryBarrierCount,
bufferMemoryBarriers, params->imageMemoryBarrierCount,
imageMemoryBarriers);
break;
}
case CommandID::PushConstants:
{
const PushConstantsParams *params =
getParamPtr<PushConstantsParams>(currentCommand);
vkCmdPushConstants(cmdBuffer, params->layout, params->flag, params->offset,
params->size, params->data);
const void *data = Offset<void>(params, sizeof(PushConstantsParams));
vkCmdPushConstants(cmdBuffer, params->layout, params->flag, 0, params->size,
data);
break;
}
case CommandID::ResetEvent:
......@@ -561,37 +268,23 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
vkCmdSetEvent(cmdBuffer, params->event, params->stageMask);
break;
}
case CommandID::SetScissor:
{
const SetScissorParams *params = getParamPtr<SetScissorParams>(currentCommand);
vkCmdSetScissor(cmdBuffer, params->firstScissor, params->scissorCount,
params->scissors);
break;
}
case CommandID::SetViewport:
{
const SetViewportParams *params =
getParamPtr<SetViewportParams>(currentCommand);
vkCmdSetViewport(cmdBuffer, params->firstViewport, params->viewportCount,
params->viewports);
break;
}
case CommandID::UpdateBuffer:
{
const UpdateBufferParams *params =
getParamPtr<UpdateBufferParams>(currentCommand);
vkCmdUpdateBuffer(cmdBuffer, params->buffer, params->dstOffset,
params->dataSize, params->data);
break;
}
case CommandID::WaitEvents:
{
const WaitEventsParams *params = getParamPtr<WaitEventsParams>(currentCommand);
vkCmdWaitEvents(cmdBuffer, params->eventCount, params->events,
params->srcStageMask, params->dstStageMask,
params->memoryBarrierCount, params->memoryBarriers,
params->bufferMemoryBarrierCount, params->bufferMemoryBarriers,
params->imageMemoryBarrierCount, params->imageMemoryBarriers);
const VkEvent *events = Offset<VkEvent>(params, sizeof(WaitEventsParams));
const VkMemoryBarrier *memoryBarriers =
Offset<VkMemoryBarrier>(events, params->eventCount * sizeof(VkEvent));
const VkBufferMemoryBarrier *bufferMemoryBarriers =
Offset<VkBufferMemoryBarrier>(
memoryBarriers, params->memoryBarrierCount * sizeof(VkMemoryBarrier));
const VkImageMemoryBarrier *imageMemoryBarriers = Offset<VkImageMemoryBarrier>(
bufferMemoryBarriers,
params->bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier));
vkCmdWaitEvents(cmdBuffer, params->eventCount, events, params->srcStageMask,
params->dstStageMask, params->memoryBarrierCount,
memoryBarriers, params->bufferMemoryBarrierCount,
bufferMemoryBarriers, params->imageMemoryBarrierCount,
imageMemoryBarriers);
break;
}
case CommandID::WriteTimestamp:
......
src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h
......@@ -30,8 +30,9 @@ enum class CommandID : uint16_t
// Invalid cmd used to mark end of sequence of commands
Invalid = 0,
BeginQuery,
BindComputeDescriptorSets,
BindComputePipeline,
BindDescriptorSets,
BindGraphicsDescriptorSets,
BindGraphicsPipeline,
BindIndexBuffer,
BindVertexBuffers,
......@@ -50,14 +51,12 @@ enum class CommandID : uint16_t
DrawInstanced,
EndQuery,
ImageBarrier,
MemoryBarrier,
PipelineBarrier,
PushConstants,
ResetEvent,
ResetQueryPool,
SetEvent,
SetScissor,
SetViewport,
UpdateBuffer,
WaitEvents,
WriteTimestamp,
};
......@@ -69,17 +68,26 @@ enum class CommandID : uint16_t
// This makes it easy to know the size of params & to copy params
// TODO: Could optimize the size of some of these structs through bit-packing
// and customizing sizing based on limited parameter sets used by ANGLE
struct BindDescriptorSetParams
struct BindPipelineParams
{
VkPipeline pipeline;
};
VERIFY_4_BYTE_ALIGNMENT(BindPipelineParams)
struct BindGraphicsDescriptorSetParams
{
VkPipelineBindPoint bindPoint;
VkPipelineLayout layout;
uint32_t firstSet;
uint32_t descriptorSetCount;
const VkDescriptorSet *descriptorSets;
uint32_t dynamicOffsetCount;
const uint32_t *dynamicOffsets;
};
VERIFY_4_BYTE_ALIGNMENT(BindDescriptorSetParams)
VERIFY_4_BYTE_ALIGNMENT(BindGraphicsDescriptorSetParams)
struct BindComputeDescriptorSetParams
{
VkPipelineLayout layout;
};
VERIFY_4_BYTE_ALIGNMENT(BindComputeDescriptorSetParams)
struct BindIndexBufferParams
{
......@@ -89,12 +97,6 @@ struct BindIndexBufferParams
};
VERIFY_4_BYTE_ALIGNMENT(BindIndexBufferParams)
struct BindPipelineParams
{
VkPipeline pipeline;
};
VERIFY_4_BYTE_ALIGNMENT(BindPipelineParams)
struct BindVertexBuffersParams
{
// ANGLE always has firstBinding of 0 so not storing that currently
......@@ -105,12 +107,9 @@ VERIFY_4_BYTE_ALIGNMENT(BindVertexBuffersParams)
struct BlitImageParams
{
VkImage srcImage;
VkImageLayout srcImageLayout;
VkImage dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
const VkImageBlit *pRegions;
VkFilter filter;
VkImageBlit region;
};
VERIFY_4_BYTE_ALIGNMENT(BlitImageParams)
......@@ -119,7 +118,6 @@ struct CopyBufferParams
VkBuffer srcBuffer;
VkBuffer destBuffer;
uint32_t regionCount;
const VkBufferCopy *regions;
};
VERIFY_4_BYTE_ALIGNMENT(CopyBufferParams)
......@@ -128,8 +126,7 @@ struct CopyBufferToImageParams
VkBuffer srcBuffer;
VkImage dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
const VkBufferImageCopy *regions;
VkBufferImageCopy region;
};
VERIFY_4_BYTE_ALIGNMENT(CopyBufferToImageParams)
......@@ -139,8 +136,7 @@ struct CopyImageParams
VkImageLayout srcImageLayout;
VkImage dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
const VkImageCopy *regions;
VkImageCopy region;
};
VERIFY_4_BYTE_ALIGNMENT(CopyImageParams)
......@@ -149,17 +145,14 @@ struct CopyImageToBufferParams
VkImage srcImage;
VkImageLayout srcImageLayout;
VkBuffer dstBuffer;
uint32_t regionCount;
const VkBufferImageCopy *regions;
VkBufferImageCopy region;
};
VERIFY_4_BYTE_ALIGNMENT(CopyImageToBufferParams)
struct ClearAttachmentsParams
{
uint32_t attachmentCount;
const VkClearAttachment *attachments;
uint32_t rectCount;
const VkClearRect *rects;
VkClearRect rect;
};
VERIFY_4_BYTE_ALIGNMENT(ClearAttachmentsParams)
......@@ -168,8 +161,7 @@ struct ClearColorImageParams
VkImage image;
VkImageLayout imageLayout;
VkClearColorValue color;
uint32_t rangeCount;
const VkImageSubresourceRange *ranges;
VkImageSubresourceRange range;
};
VERIFY_4_BYTE_ALIGNMENT(ClearColorImageParams)
......@@ -178,46 +170,18 @@ struct ClearDepthStencilImageParams
VkImage image;
VkImageLayout imageLayout;
VkClearDepthStencilValue depthStencil;
uint32_t rangeCount;
const VkImageSubresourceRange *ranges;
VkImageSubresourceRange range;
};
VERIFY_4_BYTE_ALIGNMENT(ClearDepthStencilImageParams)
struct UpdateBufferParams
{
VkBuffer buffer;
VkDeviceSize dstOffset;
VkDeviceSize dataSize;
const void *data;
};
VERIFY_4_BYTE_ALIGNMENT(UpdateBufferParams)
struct PushConstantsParams
{
VkPipelineLayout layout;
VkShaderStageFlags flag;
uint32_t offset;
uint32_t size;
const void *data;
};
VERIFY_4_BYTE_ALIGNMENT(PushConstantsParams)
struct SetViewportParams
{
uint32_t firstViewport;
uint32_t viewportCount;
const VkViewport *viewports;
};
VERIFY_4_BYTE_ALIGNMENT(SetViewportParams)
struct SetScissorParams
{
uint32_t firstScissor;
uint32_t scissorCount;
const VkRect2D *scissors;
};
VERIFY_4_BYTE_ALIGNMENT(SetScissorParams)
struct DrawParams
{
uint32_t vertexCount;
......@@ -254,17 +218,22 @@ struct DispatchParams
};
VERIFY_4_BYTE_ALIGNMENT(DispatchParams)
struct MemoryBarrierParams
{
VkPipelineStageFlags srcStageMask;
VkPipelineStageFlags dstStageMask;
VkMemoryBarrier memoryBarrier;
};
VERIFY_4_BYTE_ALIGNMENT(MemoryBarrierParams)
struct PipelineBarrierParams
{
VkPipelineStageFlags srcStageMask;
VkPipelineStageFlags dstStageMask;
VkDependencyFlags dependencyFlags;
uint32_t memoryBarrierCount;
const VkMemoryBarrier *memoryBarriers;
uint32_t bufferMemoryBarrierCount;
const VkBufferMemoryBarrier *bufferMemoryBarriers;
uint32_t imageMemoryBarrierCount;
const VkImageMemoryBarrier *imageMemoryBarriers;
};
VERIFY_4_BYTE_ALIGNMENT(PipelineBarrierParams)
......@@ -293,15 +262,11 @@ VERIFY_4_BYTE_ALIGNMENT(ResetEventParams)
struct WaitEventsParams
{
uint32_t eventCount;
const VkEvent *events;
VkPipelineStageFlags srcStageMask;
VkPipelineStageFlags dstStageMask;
uint32_t memoryBarrierCount;
const VkMemoryBarrier *memoryBarriers;
uint32_t bufferMemoryBarrierCount;
const VkBufferMemoryBarrier *bufferMemoryBarriers;
uint32_t imageMemoryBarrierCount;
const VkImageMemoryBarrier *imageMemoryBarriers;
};
VERIFY_4_BYTE_ALIGNMENT(WaitEventsParams)
......@@ -364,19 +329,23 @@ class SecondaryCommandBuffer final : angle::NonCopyable
~SecondaryCommandBuffer();
// Add commands
void bindDescriptorSets(VkPipelineBindPoint bindPoint,
const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets);
void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
void bindIndexBuffer(const Buffer &buffer, VkDeviceSize offset, VkIndexType indexType);
void bindComputeDescriptorSets(const PipelineLayout &layout,
const VkDescriptorSet *descriptorSets);
void bindComputePipeline(const Pipeline &pipeline);
void bindGraphicsDescriptorSets(const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets);
void bindGraphicsPipeline(const Pipeline &pipeline);
void bindComputePipeline(const Pipeline &pipeline);
void bindIndexBuffer(const Buffer &buffer, VkDeviceSize offset, VkIndexType indexType);
void bindVertexBuffers(uint32_t firstBinding,
uint32_t bindingCount,
......@@ -391,6 +360,23 @@ class SecondaryCommandBuffer final : angle::NonCopyable
const VkImageBlit *pRegions,
VkFilter filter);
void clearAttachments(uint32_t attachmentCount,
const VkClearAttachment *attachments,
uint32_t rectCount,
const VkClearRect *rects);
void clearColorImage(const Image &image,
VkImageLayout imageLayout,
const VkClearColorValue &color,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges);
void clearDepthStencilImage(const Image &image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue &depthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges);
void copyBuffer(const Buffer &srcBuffer,
const Buffer &destBuffer,
uint32_t regionCount,
......@@ -415,46 +401,25 @@ class SecondaryCommandBuffer final : angle::NonCopyable
uint32_t regionCount,
const VkBufferImageCopy *regions);
void clearAttachments(uint32_t attachmentCount,
const VkClearAttachment *attachments,
uint32_t rectCount,
const VkClearRect *rects);
void clearColorImage(const Image &image,
VkImageLayout imageLayout,
const VkClearColorValue &color,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges);
void clearDepthStencilImage(const Image &image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue &depthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges);
void updateBuffer(const Buffer &buffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void *data);
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
void pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
uint32_t size,
const void *data);
void draw(uint32_t vertexCount, uint32_t firstVertex);
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *viewports);
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *scissors);
void drawIndexed(uint32_t indexCount);
void draw(uint32_t vertexCount, uint32_t firstVertex);
void drawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount);
void drawInstanced(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex);
void drawIndexed(uint32_t indexCount);
void endQuery(VkQueryPool queryPool, uint32_t query);
void drawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount);
void imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkImageMemoryBarrier *imageMemoryBarrier);
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
void memoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkMemoryBarrier *memoryBarrier);
void pipelineBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
......@@ -466,12 +431,18 @@ class SecondaryCommandBuffer final : angle::NonCopyable
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers);
void imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkImageMemoryBarrier *imageMemoryBarrier);
void pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
uint32_t size,
const void *data);
void setEvent(VkEvent event, VkPipelineStageFlags stageMask);
void resetEvent(VkEvent event, VkPipelineStageFlags stageMask);
void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
void setEvent(VkEvent event, VkPipelineStageFlags stageMask);
void waitEvents(uint32_t eventCount,
const VkEvent *events,
VkPipelineStageFlags srcStageMask,
......@@ -483,9 +454,6 @@ class SecondaryCommandBuffer final : angle::NonCopyable
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers);
void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
void endQuery(VkQueryPool queryPool, uint32_t query);
void writeTimestamp(VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query);
......@@ -539,11 +507,13 @@ class SecondaryCommandBuffer final : angle::NonCopyable
mCommands.push_back(reinterpret_cast<CommandHeader *>(mCurrentWritePointer));
}
// Allocate and initialize memory for given commandID & variable param size
// returning a pointer to the start of the commands parameter data and updating
// mPtrCmdData to just past the fixed parameter data.
// Allocate and initialize memory for given commandID & variable param size, setting
// variableDataPtr to the byte following fixed cmd data where variable-sized ptr data will
// be written and returning a pointer to the start of the command's parameter data
template <class StructType>
ANGLE_INLINE StructType *initCommand(CommandID cmdID, size_t variableSize)
ANGLE_INLINE StructType *initCommand(CommandID cmdID,
size_t variableSize,
uint8_t **variableDataPtr)
{
constexpr size_t fixedAllocationSize = sizeof(StructType) + sizeof(CommandHeader);
const size_t allocationSize = fixedAllocationSize + variableSize;
......@@ -552,7 +522,7 @@ class SecondaryCommandBuffer final : angle::NonCopyable
{
allocateNewBlock();
}
mPtrCmdData = mCurrentWritePointer + fixedAllocationSize;
*variableDataPtr = Offset<uint8_t>(mCurrentWritePointer, fixedAllocationSize);
return commonInit<StructType>(cmdID, allocationSize);
}
......@@ -576,19 +546,14 @@ class SecondaryCommandBuffer final : angle::NonCopyable
return reinterpret_cast<const StructType *>(reinterpret_cast<const uint8_t *>(header) +
sizeof(CommandHeader));
}
// Copy sizeInBytes data from paramData to mPtrCmdData and assign *writePtr
// to mPtrCmdData. Then increment mPtrCmdData by sizeInBytes.
// Precondition: initCommand() must have already been called on the given cmd
// Copy sizeInBytes data from paramData to writePointer & return writePointer plus sizeInBytes.
template <class PtrType>
void storePointerParameter(const PtrType *paramData,
const PtrType **writePtr,
size_t sizeInBytes)
ANGLE_INLINE uint8_t *storePointerParameter(uint8_t *writePointer,
const PtrType *paramData,
size_t sizeInBytes)
{
if (sizeInBytes == 0)
return;
*writePtr = reinterpret_cast<const PtrType *>(mPtrCmdData);
memcpy(mPtrCmdData, paramData, sizeInBytes);
mPtrCmdData += sizeInBytes;
memcpy(writePointer, paramData, sizeInBytes);
return writePointer + sizeInBytes;
}
std::vector<CommandHeader *> mCommands;
......@@ -598,10 +563,6 @@ class SecondaryCommandBuffer final : angle::NonCopyable
uint8_t *mCurrentWritePointer;
size_t mCurrentBytesRemaining;
// Ptr to write variable ptr data section of cmd into.
// This is set to just past fixed parameter data when initCommand() is called
uint8_t *mPtrCmdData;
};
ANGLE_INLINE SecondaryCommandBuffer::SecondaryCommandBuffer()
......@@ -609,39 +570,57 @@ ANGLE_INLINE SecondaryCommandBuffer::SecondaryCommandBuffer()
{}
ANGLE_INLINE SecondaryCommandBuffer::~SecondaryCommandBuffer() {}
ANGLE_INLINE void SecondaryCommandBuffer::bindDescriptorSets(VkPipelineBindPoint bindPoint,
const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets)
ANGLE_INLINE void SecondaryCommandBuffer::beginQuery(VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags)
{
BeginQueryParams *paramStruct = initCommand<BeginQueryParams>(CommandID::BeginQuery);
paramStruct->queryPool = queryPool;
paramStruct->query = query;
paramStruct->flags = flags;
}
ANGLE_INLINE void SecondaryCommandBuffer::bindComputePipeline(const Pipeline &pipeline)
{
BindPipelineParams *paramStruct =
initCommand<BindPipelineParams>(CommandID::BindComputePipeline);
paramStruct->pipeline = pipeline.getHandle();
}
ANGLE_INLINE void SecondaryCommandBuffer::bindGraphicsDescriptorSets(
const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets)
{
size_t descSize = descriptorSetCount * sizeof(VkDescriptorSet);
size_t offsetSize = dynamicOffsetCount * sizeof(uint32_t);
size_t varSize = descSize + offsetSize;
BindDescriptorSetParams *paramStruct =
initCommand<BindDescriptorSetParams>(CommandID::BindDescriptorSets, varSize);
uint8_t *writePtr;
BindGraphicsDescriptorSetParams *paramStruct = initCommand<BindGraphicsDescriptorSetParams>(
CommandID::BindGraphicsDescriptorSets, descSize + offsetSize, &writePtr);
// Copy params into memory
paramStruct->bindPoint = bindPoint;
paramStruct->layout = layout.getHandle();
paramStruct->firstSet = firstSet;
paramStruct->descriptorSetCount = descriptorSetCount;
paramStruct->dynamicOffsetCount = dynamicOffsetCount;
// Copy variable sized data
storePointerParameter(descriptorSets, &paramStruct->descriptorSets, descSize);
storePointerParameter(dynamicOffsets, &paramStruct->dynamicOffsets, offsetSize);
writePtr = storePointerParameter(writePtr, descriptorSets, descSize);
storePointerParameter(writePtr, dynamicOffsets, offsetSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::bindIndexBuffer(const Buffer &buffer,
VkDeviceSize offset,
VkIndexType indexType)
ANGLE_INLINE void SecondaryCommandBuffer::bindComputeDescriptorSets(
const PipelineLayout &layout,
const VkDescriptorSet *descriptorSets)
{
BindIndexBufferParams *paramStruct =
initCommand<BindIndexBufferParams>(CommandID::BindIndexBuffer);
paramStruct->buffer = buffer.getHandle();
paramStruct->offset = offset;
paramStruct->indexType = indexType;
uint8_t *writePtr;
BindComputeDescriptorSetParams *paramStruct = initCommand<BindComputeDescriptorSetParams>(
CommandID::BindComputeDescriptorSets, sizeof(VkDescriptorSet), &writePtr);
// Copy params into memory
paramStruct->layout = layout.getHandle();
// Copy variable sized data
storePointerParameter(writePtr, descriptorSets, sizeof(VkDescriptorSet));
}
ANGLE_INLINE void SecondaryCommandBuffer::bindGraphicsPipeline(const Pipeline &pipeline)
......@@ -651,11 +630,15 @@ ANGLE_INLINE void SecondaryCommandBuffer::bindGraphicsPipeline(const Pipeline &p
paramStruct->pipeline = pipeline.getHandle();
}
ANGLE_INLINE void SecondaryCommandBuffer::bindComputePipeline(const Pipeline &pipeline)
ANGLE_INLINE void SecondaryCommandBuffer::bindIndexBuffer(const Buffer &buffer,
VkDeviceSize offset,
VkIndexType indexType)
{
BindPipelineParams *paramStruct =
initCommand<BindPipelineParams>(CommandID::BindComputePipeline);
paramStruct->pipeline = pipeline.getHandle();
BindIndexBufferParams *paramStruct =
initCommand<BindIndexBufferParams>(CommandID::BindIndexBuffer);
paramStruct->buffer = buffer.getHandle();
paramStruct->offset = offset;
paramStruct->indexType = indexType;
}
ANGLE_INLINE void SecondaryCommandBuffer::bindVertexBuffers(uint32_t firstBinding,
......@@ -664,16 +647,153 @@ ANGLE_INLINE void SecondaryCommandBuffer::bindVertexBuffers(uint32_t firstBindin
const VkDeviceSize *offsets)
{
ASSERT(firstBinding == 0);
uint8_t *writePtr;
size_t buffersSize = bindingCount * sizeof(VkBuffer);
size_t offsetsSize = bindingCount * sizeof(VkDeviceSize);
BindVertexBuffersParams *paramStruct = initCommand<BindVertexBuffersParams>(
CommandID::BindVertexBuffers, buffersSize + offsetsSize);
CommandID::BindVertexBuffers, buffersSize + offsetsSize, &writePtr);
// Copy params
paramStruct->bindingCount = bindingCount;
uint8_t *writePointer = Offset<uint8_t>(paramStruct, sizeof(BindVertexBuffersParams));
memcpy(writePointer, buffers, buffersSize);
writePointer += buffersSize;
memcpy(writePointer, offsets, offsetsSize);
writePtr = storePointerParameter(writePtr, buffers, buffersSize);
storePointerParameter(writePtr, offsets, offsetsSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::blitImage(const Image &srcImage,
VkImageLayout srcImageLayout,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit *pRegions,
VkFilter filter)
{
// Currently ANGLE uses limited params so verify those assumptions and update if they change
ASSERT(srcImageLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
ASSERT(dstImageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
ASSERT(regionCount == 1);
BlitImageParams *paramStruct = initCommand<BlitImageParams>(CommandID::BlitImage);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->dstImage = dstImage.getHandle();
paramStruct->filter = filter;
paramStruct->region = pRegions[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::clearAttachments(uint32_t attachmentCount,
const VkClearAttachment *attachments,
uint32_t rectCount,
const VkClearRect *rects)
{
ASSERT(rectCount == 1);
uint8_t *writePtr;
size_t attachSize = attachmentCount * sizeof(VkClearAttachment);
ClearAttachmentsParams *paramStruct =
initCommand<ClearAttachmentsParams>(CommandID::ClearAttachments, attachSize, &writePtr);
paramStruct->attachmentCount = attachmentCount;
paramStruct->rect = rects[0];
// Copy variable sized data
storePointerParameter(writePtr, attachments, attachSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::clearColorImage(const Image &image,
VkImageLayout imageLayout,
const VkClearColorValue &color,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges)
{
ASSERT(rangeCount == 1);
ClearColorImageParams *paramStruct =
initCommand<ClearColorImageParams>(CommandID::ClearColorImage);
paramStruct->image = image.getHandle();
paramStruct->imageLayout = imageLayout;
paramStruct->color = color;
paramStruct->range = ranges[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::clearDepthStencilImage(
const Image &image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue &depthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange *ranges)
{
ASSERT(rangeCount == 1);
ClearDepthStencilImageParams *paramStruct =
initCommand<ClearDepthStencilImageParams>(CommandID::ClearDepthStencilImage);
paramStruct->image = image.getHandle();
paramStruct->imageLayout = imageLayout;
paramStruct->depthStencil = depthStencil;
paramStruct->range = ranges[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::copyBuffer(const Buffer &srcBuffer,
const Buffer &destBuffer,
uint32_t regionCount,
const VkBufferCopy *regions)
{
uint8_t *writePtr;
size_t regionSize = regionCount * sizeof(VkBufferCopy);
CopyBufferParams *paramStruct =
initCommand<CopyBufferParams>(CommandID::CopyBuffer, regionSize, &writePtr);
paramStruct->srcBuffer = srcBuffer.getHandle();
paramStruct->destBuffer = destBuffer.getHandle();
paramStruct->regionCount = regionCount;
// Copy variable sized data
storePointerParameter(writePtr, regions, regionSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::copyBufferToImage(VkBuffer srcBuffer,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy *regions)
{
ASSERT(regionCount == 1);
CopyBufferToImageParams *paramStruct =
initCommand<CopyBufferToImageParams>(CommandID::CopyBufferToImage);
paramStruct->srcBuffer = srcBuffer;
paramStruct->dstImage = dstImage.getHandle();
paramStruct->dstImageLayout = dstImageLayout;
paramStruct->region = regions[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::copyImage(const Image &srcImage,
VkImageLayout srcImageLayout,
const Image &dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy *regions)
{
ASSERT(regionCount == 1);
CopyImageParams *paramStruct = initCommand<CopyImageParams>(CommandID::CopyImage);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->srcImageLayout = srcImageLayout;
paramStruct->dstImage = dstImage.getHandle();
paramStruct->dstImageLayout = dstImageLayout;
paramStruct->region = regions[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::copyImageToBuffer(const Image &srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy *regions)
{
ASSERT(regionCount == 1);
CopyImageToBufferParams *paramStruct =
initCommand<CopyImageToBufferParams>(CommandID::CopyImageToBuffer);
paramStruct->srcImage = srcImage.getHandle();
paramStruct->srcImageLayout = srcImageLayout;
paramStruct->dstBuffer = dstBuffer;
paramStruct->region = regions[0];
}
ANGLE_INLINE void SecondaryCommandBuffer::dispatch(uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ)
{
DispatchParams *paramStruct = initCommand<DispatchParams>(CommandID::Dispatch);
paramStruct->groupCountX = groupCountX;
paramStruct->groupCountY = groupCountY;
paramStruct->groupCountZ = groupCountZ;
}
ANGLE_INLINE void SecondaryCommandBuffer::draw(uint32_t vertexCount, uint32_t firstVertex)
......@@ -683,6 +803,21 @@ ANGLE_INLINE void SecondaryCommandBuffer::draw(uint32_t vertexCount, uint32_t fi
paramStruct->firstVertex = firstVertex;
}
ANGLE_INLINE void SecondaryCommandBuffer::drawIndexed(uint32_t indexCount)
{
DrawIndexedParams *paramStruct = initCommand<DrawIndexedParams>(CommandID::DrawIndexed);
paramStruct->indexCount = indexCount;
}
ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstanced(uint32_t indexCount,
uint32_t instanceCount)
{
DrawIndexedInstancedParams *paramStruct =
initCommand<DrawIndexedInstancedParams>(CommandID::DrawIndexedInstanced);
paramStruct->indexCount = indexCount;
paramStruct->instanceCount = instanceCount;
}
ANGLE_INLINE void SecondaryCommandBuffer::drawInstanced(uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex)
......@@ -693,21 +828,149 @@ ANGLE_INLINE void SecondaryCommandBuffer::drawInstanced(uint32_t vertexCount,
paramStruct->firstVertex = firstVertex;
}
ANGLE_INLINE void SecondaryCommandBuffer::drawIndexed(uint32_t indexCount)
ANGLE_INLINE void SecondaryCommandBuffer::endQuery(VkQueryPool queryPool, uint32_t query)
{
DrawIndexedParams *paramStruct = initCommand<DrawIndexedParams>(CommandID::DrawIndexed);
paramStruct->indexCount = indexCount;
EndQueryParams *paramStruct = initCommand<EndQueryParams>(CommandID::EndQuery);
paramStruct->queryPool = queryPool;
paramStruct->query = query;
}
ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstanced(uint32_t indexCount,
uint32_t instanceCount)
ANGLE_INLINE void SecondaryCommandBuffer::imageBarrier(
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkImageMemoryBarrier *imageMemoryBarrier)
{
DrawIndexedInstancedParams *paramStruct =
initCommand<DrawIndexedInstancedParams>(CommandID::DrawIndexedInstanced);
paramStruct->indexCount = indexCount;
paramStruct->instanceCount = instanceCount;
ImageBarrierParams *paramStruct = initCommand<ImageBarrierParams>(CommandID::ImageBarrier);
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->imageMemoryBarrier = *imageMemoryBarrier;
}
ANGLE_INLINE void SecondaryCommandBuffer::memoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkMemoryBarrier *memoryBarrier)
{
MemoryBarrierParams *paramStruct = initCommand<MemoryBarrierParams>(CommandID::MemoryBarrier);
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->memoryBarrier = *memoryBarrier;
}
ANGLE_INLINE void SecondaryCommandBuffer::pipelineBarrier(
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers)
{
uint8_t *writePtr;
size_t memBarrierSize = memoryBarrierCount * sizeof(VkMemoryBarrier);
size_t buffBarrierSize = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
size_t imgBarrierSize = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
PipelineBarrierParams *paramStruct = initCommand<PipelineBarrierParams>(
CommandID::PipelineBarrier, memBarrierSize + buffBarrierSize + imgBarrierSize, &writePtr);
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->dependencyFlags = dependencyFlags;
paramStruct->memoryBarrierCount = memoryBarrierCount;
paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
paramStruct->imageMemoryBarrierCount = imageMemoryBarrierCount;
// Copy variable sized data
writePtr = storePointerParameter(writePtr, memoryBarriers, memBarrierSize);
writePtr = storePointerParameter(writePtr, bufferMemoryBarriers, buffBarrierSize);
storePointerParameter(writePtr, imageMemoryBarriers, imgBarrierSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
uint32_t size,
const void *data)
{
ASSERT(size == static_cast<size_t>(size));
ASSERT(offset == 0);
uint8_t *writePtr;
PushConstantsParams *paramStruct = initCommand<PushConstantsParams>(
CommandID::PushConstants, static_cast<size_t>(size), &writePtr);
paramStruct->layout = layout.getHandle();
paramStruct->flag = flag;
paramStruct->size = size;
// Copy variable sized data
storePointerParameter(writePtr, data, static_cast<size_t>(size));
}
ANGLE_INLINE void SecondaryCommandBuffer::resetEvent(VkEvent event, VkPipelineStageFlags stageMask)
{
ResetEventParams *paramStruct = initCommand<ResetEventParams>(CommandID::ResetEvent);
paramStruct->event = event;
paramStruct->stageMask = stageMask;
}
ANGLE_INLINE void SecondaryCommandBuffer::resetQueryPool(VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount)
{
ResetQueryPoolParams *paramStruct =
initCommand<ResetQueryPoolParams>(CommandID::ResetQueryPool);
paramStruct->queryPool = queryPool;
paramStruct->firstQuery = firstQuery;
paramStruct->queryCount = queryCount;
}
ANGLE_INLINE void SecondaryCommandBuffer::setEvent(VkEvent event, VkPipelineStageFlags stageMask)
{
SetEventParams *paramStruct = initCommand<SetEventParams>(CommandID::SetEvent);
paramStruct->event = event;
paramStruct->stageMask = stageMask;
}
ANGLE_INLINE void SecondaryCommandBuffer::waitEvents(
uint32_t eventCount,
const VkEvent *events,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers)
{
uint8_t *writePtr;
size_t eventSize = eventCount * sizeof(VkEvent);
size_t memBarrierSize = memoryBarrierCount * sizeof(VkMemoryBarrier);
size_t buffBarrierSize = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
size_t imgBarrierSize = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
WaitEventsParams *paramStruct = initCommand<WaitEventsParams>(
CommandID::WaitEvents, eventSize + memBarrierSize + buffBarrierSize + imgBarrierSize,
&writePtr);
paramStruct->eventCount = eventCount;
paramStruct->srcStageMask = srcStageMask;
paramStruct->dstStageMask = dstStageMask;
paramStruct->memoryBarrierCount = memoryBarrierCount;
paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
paramStruct->imageMemoryBarrierCount = imageMemoryBarrierCount;
// Copy variable sized data
writePtr = storePointerParameter(writePtr, events, eventSize);
writePtr = storePointerParameter(writePtr, memoryBarriers, memBarrierSize);
writePtr = storePointerParameter(writePtr, bufferMemoryBarriers, buffBarrierSize);
storePointerParameter(writePtr, imageMemoryBarriers, imgBarrierSize);
}
ANGLE_INLINE void SecondaryCommandBuffer::writeTimestamp(VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query)
{
WriteTimestampParams *paramStruct =
initCommand<WriteTimestampParams>(CommandID::WriteTimestamp);
paramStruct->pipelineStage = pipelineStage;
paramStruct->queryPool = queryPool;
paramStruct->query = query;
}
} // namespace priv
} // namespace vk
} // namespace rx
......
src/libANGLE/renderer/vulkan/UtilsVk.cpp
......@@ -316,8 +316,6 @@ angle::Result UtilsVk::setupProgram(vk::Context *context,
RendererVk *renderer = context->getRenderer();
bool isCompute = function >= Function::ComputeStartIndex;
VkPipelineBindPoint bindPoint =
isCompute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
VkShaderStageFlags pushConstantsShaderStage =
isCompute ? VK_SHADER_STAGE_COMPUTE_BIT : VK_SHADER_STAGE_FRAGMENT_BIT;
......@@ -336,6 +334,10 @@ angle::Result UtilsVk::setupProgram(vk::Context *context,
ANGLE_TRY(program->getComputePipeline(context, pipelineLayout.get(), &pipelineAndSerial));
pipelineAndSerial->updateSerial(serial);
commandBuffer->bindComputePipeline(pipelineAndSerial->get());
if (descriptorSet != VK_NULL_HANDLE)
{
commandBuffer->bindComputeDescriptorSets(pipelineLayout.get(), &descriptorSet);
}
}
else
{
......@@ -351,12 +353,11 @@ angle::Result UtilsVk::setupProgram(vk::Context *context,
pipelineLayout.get(), *pipelineDesc, gl::AttributesMask(), &descPtr, &helper));
helper->updateSerial(serial);
commandBuffer->bindGraphicsPipeline(helper->getPipeline());
}
if (descriptorSet != VK_NULL_HANDLE)
{
commandBuffer->bindDescriptorSets(bindPoint, pipelineLayout.get(), 0, 1, &descriptorSet, 0,
nullptr);
if (descriptorSet != VK_NULL_HANDLE)
{
commandBuffer->bindGraphicsDescriptorSets(pipelineLayout.get(), 0, 1, &descriptorSet, 0,
nullptr);
}
}
commandBuffer->pushConstants(pipelineLayout.get(), pushConstantsShaderStage, 0,
......
src/libANGLE/renderer/vulkan/vk_wrapper.h
......@@ -169,6 +169,33 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
void destroy(VkDevice device, const CommandPool &commandPool);
VkResult init(VkDevice device, const VkCommandBufferAllocateInfo &createInfo);
using WrappedObject::operator=;
VkResult begin(const VkCommandBufferBeginInfo &info);
void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
void beginRenderPass(const VkRenderPassBeginInfo &beginInfo, VkSubpassContents subpassContents);
void bindGraphicsDescriptorSets(const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets);
void bindGraphicsPipeline(const Pipeline &pipeline);
void bindComputeDescriptorSets(const PipelineLayout &layout,
const VkDescriptorSet *descriptorSets);
void bindComputePipeline(const Pipeline &pipeline);
void bindPipeline(VkPipelineBindPoint pipelineBindPoint, const Pipeline &pipeline);
void bindIndexBuffer(const Buffer &buffer, VkDeviceSize offset, VkIndexType indexType);
void bindVertexBuffers(uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer *buffers,
const VkDeviceSize *offsets);
void blitImage(const Image &srcImage,
VkImageLayout srcImageLayout,
const Image &dstImage,
......@@ -176,25 +203,7 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
uint32_t regionCount,
VkImageBlit *pRegions,
VkFilter filter);
using WrappedObject::operator=;
VkResult begin(const VkCommandBufferBeginInfo &info);
VkResult end();
VkResult reset();
void pipelineBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers);
void imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkImageMemoryBarrier *imageMemoryBarrier);
void clearColorImage(const Image &image,
VkImageLayout imageLayout,
const VkClearColorValue &color,
......@@ -233,8 +242,7 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
uint32_t regionCount,
const VkImageCopy *regions);
void beginRenderPass(const VkRenderPassBeginInfo &beginInfo, VkSubpassContents subpassContents);
void endRenderPass();
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
void draw(uint32_t vertexCount,
uint32_t instanceCount,
......@@ -250,31 +258,29 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
void drawIndexed(uint32_t indexCount);
void drawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount);
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
VkResult end();
void endQuery(VkQueryPool queryPool, uint32_t query);
void endRenderPass();
void executeCommands(uint32_t commandBufferCount, const CommandBuffer *commandBuffers);
void bindPipeline(VkPipelineBindPoint pipelineBindPoint, const Pipeline &pipeline);
void bindGraphicsPipeline(const Pipeline &pipeline);
void bindComputePipeline(const Pipeline &pipeline);
void imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkImageMemoryBarrier *imageMemoryBarrier);
void bindVertexBuffers(uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer *buffers,
const VkDeviceSize *offsets);
void memoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkMemoryBarrier *memoryBarrier);
void bindIndexBuffer(const Buffer &buffer, VkDeviceSize offset, VkIndexType indexType);
void bindDescriptorSets(VkPipelineBindPoint bindPoint,
const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets);
void pipelineBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier *memoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *bufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers);
void executeCommands(uint32_t commandBufferCount, const CommandBuffer *commandBuffers);
void updateBuffer(const Buffer &buffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void *data);
void pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
......@@ -282,7 +288,9 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
const void *data);
void setEvent(VkEvent event, VkPipelineStageFlags stageMask);
VkResult reset();
void resetEvent(VkEvent event, VkPipelineStageFlags stageMask);
void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
void waitEvents(uint32_t eventCount,
const VkEvent *events,
VkPipelineStageFlags srcStageMask,
......@@ -294,17 +302,10 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *imageMemoryBarriers);
void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
void endQuery(VkQueryPool queryPool, uint32_t query);
void writeTimestamp(VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query);
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *viewports);
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *scissors);
};
} // namespace priv
class Image final : public WrappedObject<Image, VkImage>
......@@ -559,8 +560,9 @@ ANGLE_INLINE void CommandBuffer::blitImage(const Image &srcImage,
VkFilter filter)
{
ASSERT(valid() && srcImage.valid() && dstImage.valid());
ASSERT(regionCount == 1);
vkCmdBlitImage(mHandle, srcImage.getHandle(), srcImageLayout, dstImage.getHandle(),
dstImageLayout, regionCount, pRegions, filter);
dstImageLayout, 1, pRegions, filter);
}
ANGLE_INLINE VkResult CommandBuffer::begin(const VkCommandBufferBeginInfo &info)
......@@ -581,6 +583,15 @@ ANGLE_INLINE VkResult CommandBuffer::reset()
return vkResetCommandBuffer(mHandle, 0);
}
ANGLE_INLINE void CommandBuffer::memoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
const VkMemoryBarrier *memoryBarrier)
{
ASSERT(valid());
vkCmdPipelineBarrier(mHandle, srcStageMask, dstStageMask, 0, 1, memoryBarrier, 0, nullptr, 0,
nullptr);
}
ANGLE_INLINE void CommandBuffer::pipelineBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
......@@ -599,7 +610,7 @@ ANGLE_INLINE void CommandBuffer::pipelineBarrier(VkPipelineStageFlags srcStageMa
ANGLE_INLINE void CommandBuffer::imageBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkImageMemoryBarrier *imageMemoryBarrier)
const VkImageMemoryBarrier *imageMemoryBarrier)
{
ASSERT(valid());
vkCmdPipelineBarrier(mHandle, srcStageMask, dstStageMask, 0, 0, nullptr, 0, nullptr, 1,
......@@ -638,8 +649,8 @@ ANGLE_INLINE void CommandBuffer::copyBufferToImage(VkBuffer srcBuffer,
{
ASSERT(valid() && dstImage.valid());
ASSERT(srcBuffer != VK_NULL_HANDLE);
vkCmdCopyBufferToImage(mHandle, srcBuffer, dstImage.getHandle(), dstImageLayout, regionCount,
regions);
ASSERT(regionCount == 1);
vkCmdCopyBufferToImage(mHandle, srcBuffer, dstImage.getHandle(), dstImageLayout, 1, regions);
}
ANGLE_INLINE void CommandBuffer::copyImageToBuffer(const Image &srcImage,
......@@ -650,8 +661,8 @@ ANGLE_INLINE void CommandBuffer::copyImageToBuffer(const Image &srcImage,
{
ASSERT(valid() && srcImage.valid());
ASSERT(dstBuffer != VK_NULL_HANDLE);
vkCmdCopyImageToBuffer(mHandle, srcImage.getHandle(), srcImageLayout, dstBuffer, regionCount,
regions);
ASSERT(regionCount == 1);
vkCmdCopyImageToBuffer(mHandle, srcImage.getHandle(), srcImageLayout, dstBuffer, 1, regions);
}
ANGLE_INLINE void CommandBuffer::clearColorImage(const Image &image,
......@@ -661,7 +672,8 @@ ANGLE_INLINE void CommandBuffer::clearColorImage(const Image &image,
const VkImageSubresourceRange *ranges)
{
ASSERT(valid());
vkCmdClearColorImage(mHandle, image.getHandle(), imageLayout, &color, rangeCount, ranges);
ASSERT(rangeCount == 1);
vkCmdClearColorImage(mHandle, image.getHandle(), imageLayout, &color, 1, ranges);
}
ANGLE_INLINE void CommandBuffer::clearDepthStencilImage(
......@@ -672,8 +684,8 @@ ANGLE_INLINE void CommandBuffer::clearDepthStencilImage(
const VkImageSubresourceRange *ranges)
{
ASSERT(valid());
vkCmdClearDepthStencilImage(mHandle, image.getHandle(), imageLayout, &depthStencil, rangeCount,
ranges);
ASSERT(rangeCount == 1);
vkCmdClearDepthStencilImage(mHandle, image.getHandle(), imageLayout, &depthStencil, 1, ranges);
}
ANGLE_INLINE void CommandBuffer::clearAttachments(uint32_t attachmentCount,
......@@ -693,6 +705,7 @@ ANGLE_INLINE void CommandBuffer::copyImage(const Image &srcImage,
const VkImageCopy *regions)
{
ASSERT(valid() && srcImage.valid() && dstImage.valid());
ASSERT(regionCount == 1);
vkCmdCopyImage(mHandle, srcImage.getHandle(), srcImageLayout, dstImage.getHandle(),
dstImageLayout, 1, regions);
}
......@@ -718,17 +731,24 @@ ANGLE_INLINE void CommandBuffer::bindIndexBuffer(const Buffer &buffer,
vkCmdBindIndexBuffer(mHandle, buffer.getHandle(), offset, indexType);
}
ANGLE_INLINE void CommandBuffer::bindDescriptorSets(VkPipelineBindPoint bindPoint,
const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets)
ANGLE_INLINE void CommandBuffer::bindComputeDescriptorSets(const PipelineLayout &layout,
const VkDescriptorSet *descriptorSets)
{
ASSERT(valid() && layout.valid());
vkCmdBindDescriptorSets(mHandle, VK_PIPELINE_BIND_POINT_COMPUTE, layout.getHandle(), 0, 1,
descriptorSets, 0, nullptr);
}
ANGLE_INLINE void CommandBuffer::bindGraphicsDescriptorSets(const PipelineLayout &layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet *descriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t *dynamicOffsets)
{
ASSERT(valid() && layout.valid());
vkCmdBindDescriptorSets(mHandle, bindPoint, layout.getHandle(), firstSet, descriptorSetCount,
descriptorSets, dynamicOffsetCount, dynamicOffsets);
vkCmdBindDescriptorSets(mHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, layout.getHandle(), firstSet,
descriptorSetCount, descriptorSets, dynamicOffsetCount, dynamicOffsets);
}
ANGLE_INLINE void CommandBuffer::executeCommands(uint32_t commandBufferCount,
......@@ -738,15 +758,6 @@ ANGLE_INLINE void CommandBuffer::executeCommands(uint32_t commandBufferCount,
vkCmdExecuteCommands(mHandle, commandBufferCount, commandBuffers[0].ptr());
}
ANGLE_INLINE void CommandBuffer::updateBuffer(const Buffer &buffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void *data)
{
ASSERT(valid() && buffer.valid());
vkCmdUpdateBuffer(mHandle, buffer.getHandle(), dstOffset, dataSize, data);
}
ANGLE_INLINE void CommandBuffer::pushConstants(const PipelineLayout &layout,
VkShaderStageFlags flag,
uint32_t offset,
......@@ -754,7 +765,8 @@ ANGLE_INLINE void CommandBuffer::pushConstants(const PipelineLayout &layout,
const void *data)
{
ASSERT(valid() && layout.valid());
vkCmdPushConstants(mHandle, layout.getHandle(), flag, offset, size, data);
ASSERT(offset == 0);
vkCmdPushConstants(mHandle, layout.getHandle(), flag, 0, size, data);
}
ANGLE_INLINE void CommandBuffer::setEvent(VkEvent event, VkPipelineStageFlags stageMask)
......@@ -816,22 +828,6 @@ ANGLE_INLINE void CommandBuffer::writeTimestamp(VkPipelineStageFlagBits pipeline
vkCmdWriteTimestamp(mHandle, pipelineStage, queryPool, query);
}
ANGLE_INLINE void CommandBuffer::setViewport(uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport *viewports)
{
ASSERT(valid());
vkCmdSetViewport(mHandle, firstViewport, viewportCount, viewports);
}
ANGLE_INLINE void CommandBuffer::setScissor(uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D *scissors)
{
ASSERT(valid());
vkCmdSetScissor(mHandle, firstScissor, scissorCount, scissors);
}
ANGLE_INLINE void CommandBuffer::draw(uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment