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