From 68f4d9d27a5e9da9245494d034c0bb9b586a733d Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 19 Nov 2015 13:12:31 +0100 Subject: [PATCH] Rename 'transitions' to image barriers/layout updates --- renderdoc/driver/vulkan/vk_core.cpp | 30 ++-- renderdoc/driver/vulkan/vk_core.h | 2 +- renderdoc/driver/vulkan/vk_debug.cpp | 26 +-- renderdoc/driver/vulkan/vk_initstate.cpp | 62 +++---- renderdoc/driver/vulkan/vk_manager.cpp | 164 +++++++++--------- renderdoc/driver/vulkan/vk_manager.h | 18 +- renderdoc/driver/vulkan/vk_replay.cpp | 142 +++++++-------- renderdoc/driver/vulkan/vk_replay.h | 6 +- renderdoc/driver/vulkan/vk_resources.h | 8 +- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 16 +- .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 8 +- .../vulkan/wrappers/vk_resource_funcs.cpp | 12 +- .../driver/vulkan/wrappers/vk_sync_funcs.cpp | 14 +- .../driver/vulkan/wrappers/vk_wsi_funcs.cpp | 8 +- 14 files changed, 258 insertions(+), 258 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 298fa9027..721e965dd 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -560,14 +560,14 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) return true; } - vector imgTransitions; + vector imgBarriers; { SCOPED_LOCK(m_ImageLayoutsLock); // not needed on replay, but harmless also - GetResourceManager()->SerialiseImageStates(m_ImageLayouts, imgTransitions); + GetResourceManager()->SerialiseImageStates(m_ImageLayouts, imgBarriers); } - if(applyInitialState && !imgTransitions.empty()) + if(applyInitialState && !imgBarriers.empty()) { VkCmdBuffer cmd = GetNextCmd(); @@ -578,12 +578,12 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; - if(!imgTransitions.empty()) + if(!imgBarriers.empty()) { vector barriers; - for(size_t i=0; i < imgTransitions.size(); i++) - barriers.push_back(&imgTransitions[i]); - ObjDisp(cmd)->CmdPipelineBarrier(Unwrap(cmd), src_stages, dest_stages, false, (uint32_t)imgTransitions.size(), (const void *const *)&barriers[0]); + for(size_t i=0; i < imgBarriers.size(); i++) + barriers.push_back(&imgBarriers[i]); + ObjDisp(cmd)->CmdPipelineBarrier(Unwrap(cmd), src_stages, dest_stages, false, (uint32_t)imgBarriers.size(), (const void *const *)&barriers[0]); } vkr = ObjDisp(cmd)->EndCommandBuffer(Unwrap(cmd)); @@ -801,7 +801,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) { imInfo.extent.width, imInfo.extent.height, 1 }, }; - VkImageMemoryBarrier bbTrans = { + VkImageMemoryBarrier bbBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -809,7 +809,7 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } }; - VkImageMemoryBarrier readTrans = { + VkImageMemoryBarrier readBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -818,19 +818,19 @@ bool WrappedVulkan::EndFrameCapture(void *dev, void *wnd) }; VkImageMemoryBarrier *barriers[] = { - &bbTrans, - &readTrans, + &bbBarrier, + &readBarrier, }; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, (void **)barriers); vt->CmdCopyImage(Unwrap(cmd), Unwrap(backbuffer), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, readbackIm, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &cpy); - // transition backbuffer back - std::swap(bbTrans.oldLayout, bbTrans.newLayout); + // barrier to switch backbuffer back to present layout + std::swap(bbBarrier.oldLayout, bbBarrier.newLayout); - readTrans.oldLayout = readTrans.newLayout; - readTrans.newLayout = VK_IMAGE_LAYOUT_GENERAL; + readBarrier.oldLayout = readBarrier.newLayout; + readBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, (void **)barriers); diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 8ae0eb640..0c28d9c74 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -238,7 +238,7 @@ private: vector curEvents; list drawStack; - vector< pair > imgtransitions; + vector< pair > imgbarriers; DrawcallTreeNode *draw; // the root draw to copy from when submitting uint32_t eventCount; // how many events are in this cmd buffer, for quick skipping diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index 821d8398b..71e72d50c 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -1079,9 +1079,9 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) GetResourceManager()->WrapResource(Unwrap(dev), m_TextAtlasView); - // need to transition image into valid state, then upload + // need to update image layout into valid state, then upload - VkImageMemoryBarrier trans = { + VkImageMemoryBarrier barrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, @@ -1090,11 +1090,11 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } }; - trans.outputMask = VK_MEMORY_OUTPUT_HOST_WRITE_BIT | VK_MEMORY_OUTPUT_TRANSFER_BIT; + barrier.outputMask = VK_MEMORY_OUTPUT_HOST_WRITE_BIT | VK_MEMORY_OUTPUT_TRANSFER_BIT; - void *barrier = (void *)&trans; + void *barrierptr = (void *)&barrier; - vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrierptr); byte *pData = NULL; vkr = vt->MapMemory(Unwrap(dev), Unwrap(m_TextAtlasMem), 0, 0, 0, (void **)&pData); @@ -1188,9 +1188,9 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) GetResourceManager()->WrapResource(Unwrap(dev), m_PickPixelImageView); - // need to transition image into valid state + // need to update image layout into valid state - VkImageMemoryBarrier trans = { + VkImageMemoryBarrier barrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, @@ -1199,9 +1199,9 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } }; - void *barrier = (void *)&trans; + void *barrierptr = (void *)&barrier; - vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrierptr); // create render pass VkAttachmentDescription attDesc = { @@ -2068,9 +2068,9 @@ ResourceId VulkanDebugManager::RenderOverlay(ResourceId texid, TextureDisplayOve vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, &m_OverlayImageView); RDCASSERT(vkr == VK_SUCCESS); - // need to transition image into valid state + // need to update image layout into valid state - VkImageMemoryBarrier trans = { + VkImageMemoryBarrier barrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, @@ -2081,9 +2081,9 @@ ResourceId VulkanDebugManager::RenderOverlay(ResourceId texid, TextureDisplayOve m_pDriver->m_ImageLayouts[GetResID(m_OverlayImage)].subresourceStates[0].newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - void *barrier = (void *)&trans; + void *barrierptr = (void *)&barrier; - vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrierptr); VkAttachmentDescription colDesc = { VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, NULL, diff --git a/renderdoc/driver/vulkan/vk_initstate.cpp b/renderdoc/driver/vulkan/vk_initstate.cpp index 2a4d0ec15..5f6719a98 100644 --- a/renderdoc/driver/vulkan/vk_initstate.cpp +++ b/renderdoc/driver/vulkan/vk_initstate.cpp @@ -969,7 +969,7 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) VkExtent3D extent = layout->extent; - VkImageMemoryBarrier srcimTrans = { + VkImageMemoryBarrier srcimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -996,35 +996,35 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) // get the offset of the first array slice in this mip region.bufferOffset = sublayout.offset; - // VKTODOMED handle getting the right origLayout for this mip, handle transitioning + // VKTODOMED handle getting the right origLayout for this mip, handle barriers for // multiple slices with different layouts etc VkImageLayout origLayout = layout->subresourceStates[0].newLayout; - // transition the real image into transfer-source - srcimTrans.oldLayout = origLayout; - srcimTrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; + // update the real image layout into transfer-source + srcimBarrier.oldLayout = origLayout; + srcimBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; // ensure all previous writes have completed - srcimTrans.outputMask = + srcimBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_SHADER_WRITE_BIT| VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_TRANSFER_BIT; // before we go reading - srcimTrans.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; + srcimBarrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; - void *barrier = (void *)&srcimTrans; + void *barrier = (void *)&srcimBarrier; ObjDisp(d)->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); ObjDisp(d)->CmdCopyImageToBuffer(Unwrap(cmd), im->real.As(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, dstBuf, 1, ®ion); // transfer back to whatever it was - srcimTrans.oldLayout = srcimTrans.newLayout; - srcimTrans.newLayout = origLayout; + srcimBarrier.oldLayout = srcimBarrier.newLayout; + srcimBarrier.newLayout = origLayout; - srcimTrans.outputMask = 0; - srcimTrans.inputMask = 0; + srcimBarrier.outputMask = 0; + srcimBarrier.inputMask = 0; ObjDisp(d)->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); @@ -1434,7 +1434,7 @@ bool WrappedVulkan::Serialise_InitialState(WrappedVkRes *res) VkExtent3D extent = imInfo.extent; - VkImageMemoryBarrier srcimTrans = { + VkImageMemoryBarrier srcimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -1460,20 +1460,20 @@ bool WrappedVulkan::Serialise_InitialState(WrappedVkRes *res) region.bufferOffset = sublayout.offset; - void *barrier = (void *)&srcimTrans; + void *barrier = (void *)&srcimBarrier; - // first we transition from undefined to destination optimal, for the copy from the buffer - srcimTrans.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - srcimTrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; + // first we update layout from undefined to destination optimal, for the copy from the buffer + srcimBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + srcimBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; ObjDisp(d)->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); ObjDisp(d)->CmdCopyBufferToImage(Unwrap(cmd), buf, Unwrap(im), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, ®ion); - // then transition into source optimal, for all subsequent copies from this immutable initial + // then update layout into source optimal, for all subsequent copies from this immutable initial // state image, to the live image. - srcimTrans.oldLayout = srcimTrans.newLayout; - srcimTrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; + srcimBarrier.oldLayout = srcimBarrier.newLayout; + srcimBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; ObjDisp(d)->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); @@ -1796,7 +1796,7 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, VulkanResourceManager VkExtent3D extent = m_CreationInfo.m_Image[id].extent; - VkImageMemoryBarrier dstimTrans = { + VkImageMemoryBarrier dstimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -1815,17 +1815,17 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, VulkanResourceManager extent, }; - dstimTrans.subresourceRange.baseMipLevel = m; + dstimBarrier.subresourceRange.baseMipLevel = m; // VKTODOMED handle getting the right origLayout for this mip, handle multiple slices with different layouts etc VkImageLayout origLayout = m_ImageLayouts[id].subresourceStates[0].newLayout; - // first transition the live image into destination optimal (the initial state + // first update the live image layout into destination optimal (the initial state // image is always and permanently in source optimal already). - dstimTrans.oldLayout = origLayout; - dstimTrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; + dstimBarrier.oldLayout = origLayout; + dstimBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; - void *barrier = (void *)&dstimTrans; + void *barrier = (void *)&dstimBarrier; ObjDisp(d)->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); @@ -1834,13 +1834,13 @@ void WrappedVulkan::Apply_InitialState(WrappedVkRes *live, VulkanResourceManager ToHandle(live), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, ®ion); - // transition the live image back - dstimTrans.oldLayout = dstimTrans.newLayout; - dstimTrans.newLayout = origLayout; + // update the live image layout back + dstimBarrier.oldLayout = dstimBarrier.newLayout; + dstimBarrier.newLayout = origLayout; // make sure the apply completes before any further work - dstimTrans.outputMask = VK_MEMORY_OUTPUT_TRANSFER_BIT; - dstimTrans.inputMask = VK_MEMORY_INPUT_HOST_READ_BIT| + dstimBarrier.outputMask = VK_MEMORY_OUTPUT_TRANSFER_BIT; + dstimBarrier.inputMask = VK_MEMORY_INPUT_HOST_READ_BIT| VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT| VK_MEMORY_INPUT_INDEX_FETCH_BIT| VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT| diff --git a/renderdoc/driver/vulkan/vk_manager.cpp b/renderdoc/driver/vulkan/vk_manager.cpp index 9683384ea..a731ce544 100644 --- a/renderdoc/driver/vulkan/vk_manager.cpp +++ b/renderdoc/driver/vulkan/vk_manager.cpp @@ -42,34 +42,34 @@ bool VulkanResourceManager::SerialisableResource(ResourceId id, VkResourceRecord return true; } -// debugging logging for transitions +// debugging logging for barriers #if 0 #define TRDBG(...) RDCLOG(__VA_ARGS__) #else #define TRDBG(...) #endif -template -void VulkanResourceManager::RecordSingleTransition(vector< pair > &dsttrans, ResourceId id, const SrcTransType &t, uint32_t nummips, uint32_t numslices) +template +void VulkanResourceManager::RecordSingleBarrier(vector< pair > &dststates, ResourceId id, const SrcBarrierType &t, uint32_t nummips, uint32_t numslices) { bool done = false; - auto it = dsttrans.begin(); - for(; it != dsttrans.end(); ++it) + auto it = dststates.begin(); + for(; it != dststates.end(); ++it) { - // image transitions are handled by initially inserting one subresource range for each aspect, + // image barriers are handled by initially inserting one subresource range for each aspect, // and whenever we need more fine-grained detail we split it immediately for one range for - // each subresource in that aspect. Thereafter if a transition comes in that covers multiple - // subresources, we transition all matching ranges. + // each subresource in that aspect. Thereafter if a barrier comes in that covers multiple + // subresources, we update all matching ranges. - // find the transitions matching this id + // find the states matching this id if(it->first < id) continue; if(it->first != id) break; if(it->second.subresourceRange.aspectMask & t.subresourceRange.aspectMask) { // we've found a range that completely matches our region, doesn't matter if that's - // a whole image and the transition is the whole image, or it's one subresource. + // a whole image and the barrier is the whole image, or it's one subresource. // note that for images with only one array/mip slice (e.g. render targets) we'll never // really have to worry about the else{} branch if(it->second.subresourceRange.baseMipLevel == t.subresourceRange.baseMipLevel && @@ -80,8 +80,8 @@ void VulkanResourceManager::RecordSingleTransition(vector< pairsecond.state == t.oldLayout); - // apply it (prevstate is from the start of all transitions, so only set once) - if(it->second.oldLayout == UNTRANSITIONED_IMG_STATE) + // apply it (prevstate is from the start of all barriers accumulated, so only set once) + if(it->second.oldLayout == UNKNOWN_PREV_IMG_LAYOUT) it->second.oldLayout = t.oldLayout; it->second.newLayout = t.newLayout; @@ -90,9 +90,9 @@ void VulkanResourceManager::RecordSingleTransition(vector< pairsecond.subresourceRange.baseArrayLayer >= t.subresourceRange.baseArrayLayer && it->second.subresourceRange.baseArrayLayer < t.subresourceRange.baseArrayLayer+numslices) { - // apply it (prevstate is from the start of all transitions, so only set once) - if(it->second.oldLayout == UNTRANSITIONED_IMG_STATE) + // apply it (prevstate is from the start of all barriers accumulated, so only set once) + if(it->second.oldLayout == UNKNOWN_PREV_IMG_LAYOUT) it->second.oldLayout = t.oldLayout; it->second.newLayout = t.newLayout; @@ -117,25 +117,25 @@ void VulkanResourceManager::RecordSingleTransition(vector< pairsecond.subresourceRange.mipLevels > 1 || it->second.subresourceRange.arraySize > 1) { pair existing = *it; // remember where we were in the array, as after this iterators will be // invalidated. - size_t offs = it - dsttrans.begin(); + size_t offs = it - dststates.begin(); size_t count = it->second.subresourceRange.mipLevels * it->second.subresourceRange.arraySize; // only insert count-1 as we want count entries total - one per subresource - dsttrans.insert(it, count-1, existing); + dststates.insert(it, count-1, existing); // it now points at the first subresource, but we need to modify the ranges // to be valid - it = dsttrans.begin()+offs; + it = dststates.begin()+offs; for(size_t i=0; i < count; i++) { @@ -149,7 +149,7 @@ void VulkanResourceManager::RecordSingleTransition(vector< pairsecond.subresourceRange.baseArrayLayer >= t.subresourceRange.baseArrayLayer && it->second.subresourceRange.baseArrayLayer < t.subresourceRange.baseArrayLayer+numslices) { - // apply it (prevstate is from the start of all transitions, so only set once) - if(it->second.oldLayout == UNTRANSITIONED_IMG_STATE) + // apply it (prevstate is from the start of all barriers accumulated, so only set once) + if(it->second.oldLayout == UNKNOWN_PREV_IMG_LAYOUT) it->second.oldLayout = t.oldLayout; it->second.newLayout = t.newLayout; @@ -182,48 +182,48 @@ void VulkanResourceManager::RecordSingleTransition(vector< pair > &trans, map &states, - uint32_t numTransitions, const VkImageMemoryBarrier *transitions) +void VulkanResourceManager::RecordBarriers(vector< pair > &states, map &layouts, + uint32_t numBarriers, const VkImageMemoryBarrier *barriers) { - TRDBG("Recording %u transitions", numTransitions); + TRDBG("Recording %u barriers", numBarriers); - for(uint32_t ti=0; ti < numTransitions; ti++) + for(uint32_t ti=0; ti < numBarriers; ti++) { - const VkImageMemoryBarrier &t = transitions[ti]; + const VkImageMemoryBarrier &t = barriers[ti]; ResourceId id = m_State < WRITING ? GetNonDispWrapper(t.image)->id : GetResID(t.image); uint32_t nummips = t.subresourceRange.mipLevels; uint32_t numslices = t.subresourceRange.arraySize; - if(nummips == VK_REMAINING_MIP_LEVELS) nummips = states[id].mipLevels - t.subresourceRange.baseMipLevel; - if(numslices == VK_REMAINING_ARRAY_LAYERS) numslices = states[id].arraySize - t.subresourceRange.baseArrayLayer; + if(nummips == VK_REMAINING_MIP_LEVELS) nummips = layouts[id].mipLevels - t.subresourceRange.baseMipLevel; + if(numslices == VK_REMAINING_ARRAY_LAYERS) numslices = layouts[id].arraySize - t.subresourceRange.baseArrayLayer; - RecordSingleTransition(trans, id, t, nummips, numslices); + RecordSingleBarrier(states, id, t, nummips, numslices); } - TRDBG("Post-record, there are %u transitions", (uint32_t)trans.size()); + TRDBG("Post-record, there are %u states", (uint32_t)states.size()); } -void VulkanResourceManager::MergeTransitions(vector< pair > &dsttrans, - vector< pair > &srctrans) +void VulkanResourceManager::MergeBarriers(vector< pair > &dststates, + vector< pair > &srcstates) { - TRDBG("Merging %u transitions", (uint32_t)srctrans.size()); + TRDBG("Merging %u states", (uint32_t)srcstates.size()); - for(size_t ti=0; ti < srctrans.size(); ti++) + for(size_t ti=0; ti < srcstates.size(); ti++) { - const ImageRegionState &t = srctrans[ti].second; - RecordSingleTransition(dsttrans, srctrans[ti].first, t, t.subresourceRange.mipLevels, t.subresourceRange.arraySize); + const ImageRegionState &t = srcstates[ti].second; + RecordSingleBarrier(dststates, srcstates[ti].first, t, t.subresourceRange.mipLevels, t.subresourceRange.arraySize); } - TRDBG("Post-merge, there are %u transitions", (uint32_t)dsttrans.size()); + TRDBG("Post-merge, there are %u states", (uint32_t)dststates.size()); } -void VulkanResourceManager::SerialiseImageStates(map &states, vector &transitions) +void VulkanResourceManager::SerialiseImageStates(map &states, vector &barriers) { Serialiser *localSerialiser = m_pSerialiser; @@ -253,7 +253,7 @@ void VulkanResourceManager::SerialiseImageStates(map & t.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; t.pNext = NULL; // these input masks aren't used, we need to apply a global memory barrier - // to memory each time we restart log replaying. These transitions are just + // to memory each time we restart log replaying. These barriers are just // to get images into the right layout t.inputMask = 0; t.outputMask = 0; @@ -264,7 +264,7 @@ void VulkanResourceManager::SerialiseImageStates(map & t.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; t.newLayout = state.newLayout; t.subresourceRange = state.subresourceRange; - transitions.push_back(t); + barriers.push_back(t); vec.push_back(std::make_pair(liveid, state)); } } @@ -272,16 +272,16 @@ void VulkanResourceManager::SerialiseImageStates(map & if(m_State >= WRITING) srcit++; } - ApplyTransitions(vec, states); + ApplyBarriers(vec, states); for(size_t i=0; i < vec.size(); i++) - transitions[i].oldLayout = vec[i].second.oldLayout; + barriers[i].oldLayout = vec[i].second.oldLayout; - // erase any do-nothing transitions - for(auto it=transitions.begin(); it != transitions.end();) + // erase any do-nothing barriers + for(auto it=barriers.begin(); it != barriers.end();) { if(it->oldLayout == it->newLayout) - it = transitions.erase(it); + it = barriers.erase(it); else ++it; } @@ -303,36 +303,36 @@ void VulkanResourceManager::MarkSparseMapReferenced(SparseMapping *sparse) MarkResourceFrameReferenced(GetResID(sparse->pages[a][i].first), eFrameRef_Read); } -void VulkanResourceManager::ApplyTransitions(vector< pair > &trans, map &states) +void VulkanResourceManager::ApplyBarriers(vector< pair > &states, map &layouts) { - TRDBG("Applying %u transitions", (uint32_t)trans.size()); + TRDBG("Applying %u barriers", (uint32_t)states.size()); - for(size_t ti=0; ti < trans.size(); ti++) + for(size_t ti=0; ti < states.size(); ti++) { - ResourceId id = trans[ti].first; - ImageRegionState &t = trans[ti].second; + ResourceId id = states[ti].first; + ImageRegionState &t = states[ti].second; - TRDBG("Applying transition to %llu", GetOriginalID(id)); + TRDBG("Applying barrier to %llu", GetOriginalID(id)); - auto stit = states.find(id); + auto stit = layouts.find(id); - if(stit == states.end()) + if(stit == layouts.end()) { - TRDBG("Didn't find ID in image states"); + TRDBG("Didn't find ID in image layouts"); continue; } uint32_t nummips = t.subresourceRange.mipLevels; uint32_t numslices = t.subresourceRange.arraySize; - if(nummips == VK_REMAINING_MIP_LEVELS) nummips = states[id].mipLevels; - if(numslices == VK_REMAINING_ARRAY_LAYERS) numslices = states[id].arraySize; + if(nummips == VK_REMAINING_MIP_LEVELS) nummips = layouts[id].mipLevels; + if(numslices == VK_REMAINING_ARRAY_LAYERS) numslices = layouts[id].arraySize; if(nummips == 0) nummips = 1; if(numslices == 0) numslices = 1; if(t.oldLayout == t.newLayout) continue; - TRDBG("Transition of %s (%u->%u, %u->%u) from %s to %s", + TRDBG("Barrier of %s (%u->%u, %u->%u) from %s to %s", ToStr::Get(t.subresourceRange.aspect).c_str(), t.subresourceRange.baseMipLevel, t.subresourceRange.mipLevels, t.subresourceRange.baseArrayLayer, t.subresourceRange.arraySize, @@ -351,15 +351,15 @@ void VulkanResourceManager::ApplyTransitions(vector< pairrange.baseArrayLayer, it->range.arraySize, ToStr::Get(it->oldLayout).c_str(), ToStr::Get(it->newLayout).c_str()); - // image transitions are handled by initially inserting one subresource range for each aspect, + // image barriers are handled by initially inserting one subresource range for each aspect, // and whenever we need more fine-grained detail we split it immediately for one range for - // each subresource in that aspect. Thereafter if a transition comes in that covers multiple - // subresources, we transition all matching ranges. + // each subresource in that aspect. Thereafter if a barrier comes in that covers multiple + // subresources, we update all matching ranges. if(it->subresourceRange.aspectMask & t.subresourceRange.aspectMask) { // we've found a range that completely matches our region, doesn't matter if that's - // a whole image and the transition is the whole image, or it's one subresource. + // a whole image and the barrier is the whole image, or it's one subresource. // note that for images with only one array/mip slice (e.g. render targets) we'll never // really have to worry about the else{} branch if(it->subresourceRange.baseMipLevel == t.subresourceRange.baseMipLevel && @@ -368,9 +368,9 @@ void VulkanResourceManager::ApplyTransitions(vector< pairsubresourceRange.arraySize == numslices) { /* - RDCASSERT(t.prevstate == UNTRANSITIONED_IMG_STATE || it->state == UNTRANSITIONED_IMG_STATE || // renderdoc untracked/ignored - it->state == t.prevstate || // valid transition - t.prevstate == VK_IMAGE_LAYOUT_UNDEFINED); // can transition from UNDEFINED to any state + RDCASSERT(t.prevstate == UNKNOWN_PREV_IMG_LAYOUT || it->state == UNKNOWN_PREV_IMG_LAYOUT || // renderdoc untracked/ignored + it->state == t.prevstate || // valid barrier + t.prevstate == VK_IMAGE_LAYOUT_UNDEFINED); // can barrier from UNDEFINED to any state */ t.oldLayout = it->newLayout; it->newLayout = t.newLayout; @@ -380,9 +380,9 @@ void VulkanResourceManager::ApplyTransitions(vector< pairsubresourceRange.baseArrayLayer >= t.subresourceRange.baseArrayLayer && it->subresourceRange.baseArrayLayer < t.subresourceRange.baseArrayLayer+numslices) { - // apply it (prevstate is from the start of all transitions, so only set once) - if(it->oldLayout == UNTRANSITIONED_IMG_STATE) + // apply it (prevstate is from the start of all barriers accumulated, so only set once) + if(it->oldLayout == UNKNOWN_PREV_IMG_LAYOUT) it->oldLayout = t.oldLayout; it->newLayout = t.newLayout; @@ -407,10 +407,10 @@ void VulkanResourceManager::ApplyTransitions(vector< pairsubresourceRange.mipLevels > 1 || it->subresourceRange.arraySize > 1) { ImageRegionState existing = *it; @@ -448,8 +448,8 @@ void VulkanResourceManager::ApplyTransitions(vector< pairsubresourceRange.baseArrayLayer >= t.subresourceRange.baseArrayLayer && it->subresourceRange.baseArrayLayer < t.subresourceRange.baseArrayLayer+numslices) { - // apply it (prevstate is from the start of all transitions, so only set once) - if(it->oldLayout == UNTRANSITIONED_IMG_STATE) + // apply it (prevstate is from the start of all barriers accumulated, so only set once) + if(it->oldLayout == UNKNOWN_PREV_IMG_LAYOUT) it->oldLayout = t.oldLayout; it->newLayout = t.newLayout; @@ -471,7 +471,7 @@ void VulkanResourceManager::ApplyTransitions(vector< pair::ParentType *)ResourceManager::GetCurrentResource(id)) ); } - // handling memory & image transitions - template - void RecordSingleTransition(vector< pair > &trans, ResourceId id, const SrcTransType &t, uint32_t nummips, uint32_t numslices); + // handling memory & image layouts + template + void RecordSingleBarrier(vector< pair > &states, ResourceId id, const SrcBarrierType &t, uint32_t nummips, uint32_t numslices); - void RecordTransitions(vector< pair > &trans, map &states, - uint32_t numTransitions, const VkImageMemoryBarrier *transitions); + void RecordBarriers(vector< pair > &states, map &layouts, + uint32_t numBarriers, const VkImageMemoryBarrier *barriers); - void MergeTransitions(vector< pair > &dsttrans, - vector< pair > &srctrans); + void MergeBarriers(vector< pair > &dststates, + vector< pair > &srcstates); - void ApplyTransitions(vector< pair > &trans, map &states); + void ApplyBarriers(vector< pair > &states, map &layouts); - void SerialiseImageStates(map &states, vector &transitions); + void SerialiseImageStates(map &states, vector &barriers); ResourceId GetID(WrappedVkRes *res) { diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 9c011c272..e44be2e92 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -129,13 +129,13 @@ VulkanReplay::OutputWindow::OutputWindow() : wnd(NULL_WND_HANDLE), width(0), hei VK_NULL_HANDLE, { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } }; - for(size_t i=0; i < ARRAY_COUNT(coltrans); i++) - coltrans[i] = t; + for(size_t i=0; i < ARRAY_COUNT(colBarrier); i++) + colBarrier[i] = t; - bbtrans = t; + bbBarrier = t; t.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - depthtrans = t; + depthBarrier = t; } void VulkanReplay::OutputWindow::SetCol(VkDeviceMemory mem, VkImage img) @@ -350,8 +350,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, { colimg[i] = imgs[i]; GetResourceManager()->WrapResource(Unwrap(device), colimg[i]); - coltrans[i].image = Unwrap(colimg[i]); - coltrans[i].oldLayout = coltrans[i].newLayout = VK_IMAGE_LAYOUT_UNDEFINED; + colBarrier[i].image = Unwrap(colimg[i]); + colBarrier[i].oldLayout = colBarrier[i].newLayout = VK_IMAGE_LAYOUT_UNDEFINED; } curidx = 0; @@ -392,8 +392,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = vt->BindImageMemory(Unwrap(device), Unwrap(dsimg), Unwrap(dsmem), 0); RDCASSERT(vkr == VK_SUCCESS); - depthtrans.image = Unwrap(dsimg); - depthtrans.oldLayout = depthtrans.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; + depthBarrier.image = Unwrap(dsimg); + depthBarrier.oldLayout = depthBarrier.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImageViewCreateInfo info = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, NULL, @@ -500,8 +500,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, vkr = vt->BindImageMemory(Unwrap(device), Unwrap(bb), Unwrap(bbmem), 0); RDCASSERT(vkr == VK_SUCCESS); - bbtrans.image = Unwrap(bb); - bbtrans.oldLayout = bbtrans.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; + bbBarrier.image = Unwrap(bb); + bbBarrier.oldLayout = bbBarrier.newLayout = VK_IMAGE_LAYOUT_UNDEFINED; } { @@ -845,7 +845,7 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ VkResult vkr = VK_SUCCESS; { - VkImageMemoryBarrier pickimTrans = { + VkImageMemoryBarrier pickimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -853,21 +853,21 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } }; - // transition from color attachment to transfer source, with proper memory barriers - pickimTrans.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT; - pickimTrans.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; + // update image layout from color attachment to transfer source, with proper memory barriers + pickimBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT; + pickimBarrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); RDCASSERT(vkr == VK_SUCCESS); - void *barrier = (void *)&pickimTrans; + void *barrier = (void *)&pickimBarrier; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - pickimTrans.oldLayout = pickimTrans.newLayout; + pickimBarrier.oldLayout = pickimBarrier.newLayout; - pickimTrans.outputMask = 0; - pickimTrans.inputMask = 0; + pickimBarrier.outputMask = 0; + pickimBarrier.inputMask = 0; // do copy VkBufferImageCopy region = { @@ -878,8 +878,8 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ }; vt->CmdCopyImageToBuffer(Unwrap(cmd), Unwrap(GetDebugManager()->m_PickPixelImage), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, Unwrap(GetDebugManager()->m_PickPixelReadbackBuffer.buf), 1, ®ion); - // transition back to color attachment - pickimTrans.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + // update image layout back to color attachment + pickimBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); vt->EndCommandBuffer(Unwrap(cmd)); @@ -1090,7 +1090,7 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn vt->UpdateDescriptorSets(Unwrap(dev), ARRAY_COUNT(writeSet), writeSet, 0, NULL); - VkImageMemoryBarrier srcimTrans = { + VkImageMemoryBarrier srcimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, origLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -1099,25 +1099,25 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn }; // ensure all previous writes have completed - srcimTrans.outputMask = + srcimBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_SHADER_WRITE_BIT| VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_TRANSFER_BIT; // before we go reading - srcimTrans.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; + srcimBarrier.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - void *barrier = (void *)&srcimTrans; + void *barrier = (void *)&srcimBarrier; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - srcimTrans.oldLayout = srcimTrans.newLayout; + srcimBarrier.oldLayout = srcimBarrier.newLayout; - srcimTrans.outputMask = 0; - srcimTrans.inputMask = 0; + srcimBarrier.outputMask = 0; + srcimBarrier.inputMask = 0; { vt->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); @@ -1138,7 +1138,7 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn vt->CmdEndRenderPass(Unwrap(cmd)); } - srcimTrans.newLayout = origLayout; + srcimBarrier.newLayout = origLayout; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); vt->EndCommandBuffer(Unwrap(cmd)); @@ -2319,21 +2319,21 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) RDCASSERT(vkr == VK_SUCCESS); void *barrier[] = { - (void *)&outw.bbtrans, - (void *)&outw.coltrans[outw.curidx], - (void *)&outw.depthtrans, + (void *)&outw.bbBarrier, + (void *)&outw.colBarrier[outw.curidx], + (void *)&outw.depthBarrier, }; - outw.depthtrans.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + outw.depthBarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - outw.coltrans[outw.curidx].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; + outw.bbBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + outw.colBarrier[outw.curidx].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, depth ? 3 : 2, barrier); - outw.depthtrans.oldLayout = outw.depthtrans.newLayout; - outw.bbtrans.oldLayout = outw.bbtrans.newLayout; - outw.coltrans[outw.curidx].oldLayout = outw.coltrans[outw.curidx].newLayout; + outw.depthBarrier.oldLayout = outw.depthBarrier.newLayout; + outw.bbBarrier.oldLayout = outw.bbBarrier.newLayout; + outw.colBarrier[outw.curidx].oldLayout = outw.colBarrier[outw.curidx].newLayout; vt->EndCommandBuffer(Unwrap(cmd)); } @@ -2355,7 +2355,7 @@ void VulkanReplay::ClearOutputWindowColour(uint64_t id, float col[4]) VkResult vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); RDCASSERT(vkr == VK_SUCCESS); - vt->CmdClearColorImage(Unwrap(cmd), Unwrap(outw.bb), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, (VkClearColorValue *)col, 1, &outw.bbtrans.subresourceRange); + vt->CmdClearColorImage(Unwrap(cmd), Unwrap(outw.bb), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, (VkClearColorValue *)col, 1, &outw.bbBarrier.subresourceRange); vt->EndCommandBuffer(Unwrap(cmd)); } @@ -2379,7 +2379,7 @@ void VulkanReplay::ClearOutputWindowDepth(uint64_t id, float depth, uint8_t sten VkClearDepthStencilValue ds = { depth, stencil }; - vt->CmdClearDepthStencilImage(Unwrap(cmd), Unwrap(outw.dsimg), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, &ds, 1, &outw.depthtrans.subresourceRange); + vt->CmdClearDepthStencilImage(Unwrap(cmd), Unwrap(outw.dsimg), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, &ds, 1, &outw.depthBarrier.subresourceRange); vt->EndCommandBuffer(Unwrap(cmd)); } @@ -2402,18 +2402,18 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) RDCASSERT(vkr == VK_SUCCESS); void *barrier[] = { - (void *)&outw.bbtrans, - (void *)&outw.coltrans[outw.curidx], + (void *)&outw.bbBarrier, + (void *)&outw.colBarrier[outw.curidx], }; // ensure rendering has completed before copying - outw.bbtrans.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT; - outw.bbtrans.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; - outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; + outw.bbBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT; + outw.bbBarrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT; + outw.bbBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, barrier); - outw.bbtrans.oldLayout = outw.bbtrans.newLayout; - outw.bbtrans.outputMask = 0; - outw.bbtrans.inputMask = 0; + outw.bbBarrier.oldLayout = outw.bbBarrier.newLayout; + outw.bbBarrier.outputMask = 0; + outw.bbBarrier.inputMask = 0; VkImageCopy cpy = { { VK_IMAGE_ASPECT_COLOR, 0, 0, 1 }, @@ -2436,22 +2436,22 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) else vt->CmdCopyImage(Unwrap(cmd), Unwrap(outw.bb), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, Unwrap(outw.colimg[outw.curidx]), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &cpy); - outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - outw.coltrans[outw.curidx].newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR; + outw.bbBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + outw.colBarrier[outw.curidx].newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR; // not sure what input mask should be for present, so be conservative. // make sure copy has completed before present - outw.coltrans[outw.curidx].outputMask = VK_MEMORY_OUTPUT_TRANSFER_BIT; - outw.coltrans[outw.curidx].inputMask = VK_MEMORY_INPUT_TRANSFER_BIT|VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT|VK_MEMORY_INPUT_SHADER_READ_BIT; + outw.colBarrier[outw.curidx].outputMask = VK_MEMORY_OUTPUT_TRANSFER_BIT; + outw.colBarrier[outw.curidx].inputMask = VK_MEMORY_INPUT_TRANSFER_BIT|VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT|VK_MEMORY_INPUT_SHADER_READ_BIT; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, barrier); - outw.bbtrans.oldLayout = outw.bbtrans.newLayout; - outw.coltrans[outw.curidx].oldLayout = outw.coltrans[outw.curidx].newLayout; + outw.bbBarrier.oldLayout = outw.bbBarrier.newLayout; + outw.colBarrier[outw.curidx].oldLayout = outw.colBarrier[outw.curidx].newLayout; - outw.coltrans[outw.curidx].outputMask = 0; - outw.coltrans[outw.curidx].inputMask = 0; + outw.colBarrier[outw.curidx].outputMask = 0; + outw.colBarrier[outw.curidx].inputMask = 0; vt->EndCommandBuffer(Unwrap(cmd)); @@ -3292,7 +3292,7 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, GetDebugManager()->m_HistogramUBO.Unmap(vt, dev); - VkImageMemoryBarrier srcimTrans = { + VkImageMemoryBarrier srcimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, origLayout, VK_IMAGE_LAYOUT_GENERAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -3301,25 +3301,25 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, }; // ensure all previous writes have completed - srcimTrans.outputMask = + srcimBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_SHADER_WRITE_BIT| VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_TRANSFER_BIT; // before we go reading - srcimTrans.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; + srcimBarrier.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - void *barrier = (void *)&srcimTrans; + void *barrier = (void *)&srcimBarrier; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - srcimTrans.oldLayout = srcimTrans.newLayout; + srcimBarrier.oldLayout = srcimBarrier.newLayout; - srcimTrans.outputMask = 0; - srcimTrans.inputMask = 0; + srcimBarrier.outputMask = 0; + srcimBarrier.inputMask = 0; int blocksX = (int)ceil(iminfo.extent.width/float(HGRAM_PIXELS_PER_TILE*HGRAM_TILES_PER_BLOCK)); int blocksY = (int)ceil(iminfo.extent.height/float(HGRAM_PIXELS_PER_TILE*HGRAM_TILES_PER_BLOCK)); @@ -3339,7 +3339,7 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, }; // image layout back to normal - srcimTrans.newLayout = origLayout; + srcimBarrier.newLayout = origLayout; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); // ensure shader writes complete before coalescing the tiles @@ -3502,7 +3502,7 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m GetDebugManager()->m_HistogramUBO.Unmap(vt, dev); - VkImageMemoryBarrier srcimTrans = { + VkImageMemoryBarrier srcimBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, 0, 0, origLayout, VK_IMAGE_LAYOUT_GENERAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, @@ -3511,25 +3511,25 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m }; // ensure all previous writes have completed - srcimTrans.outputMask = + srcimBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_SHADER_WRITE_BIT| VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT| VK_MEMORY_OUTPUT_TRANSFER_BIT; // before we go reading - srcimTrans.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; + srcimBarrier.inputMask = VK_MEMORY_INPUT_SHADER_READ_BIT; VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo); - void *barrier = (void *)&srcimTrans; + void *barrier = (void *)&srcimBarrier; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - srcimTrans.oldLayout = srcimTrans.newLayout; + srcimBarrier.oldLayout = srcimBarrier.newLayout; - srcimTrans.outputMask = 0; - srcimTrans.inputMask = 0; + srcimBarrier.outputMask = 0; + srcimBarrier.inputMask = 0; int blocksX = (int)ceil(iminfo.extent.width/float(HGRAM_PIXELS_PER_TILE*HGRAM_TILES_PER_BLOCK)); int blocksY = (int)ceil(iminfo.extent.height/float(HGRAM_PIXELS_PER_TILE*HGRAM_TILES_PER_BLOCK)); @@ -3551,7 +3551,7 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m }; // image layout back to normal - srcimTrans.newLayout = origLayout; + srcimBarrier.newLayout = origLayout; vt->CmdPipelineBarrier(Unwrap(cmd), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); // ensure shader writes complete before copying to readback buf diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 829561fe6..4a11432b0 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -186,12 +186,12 @@ class VulkanReplay : public IReplayDriver VkSwapchainKHR swap; uint32_t numImgs; VkImage colimg[8]; - VkImageMemoryBarrier coltrans[8]; + VkImageMemoryBarrier colBarrier[8]; VkImage bb; VkImageView bbview; VkDeviceMemory bbmem; - VkImageMemoryBarrier bbtrans; + VkImageMemoryBarrier bbBarrier; VkFramebuffer fb, fbdepth; VkRenderPass rp, rpdepth; uint32_t curidx; @@ -199,7 +199,7 @@ class VulkanReplay : public IReplayDriver VkImage dsimg; VkDeviceMemory dsmem; VkImageView dsview; - VkImageMemoryBarrier depthtrans; + VkImageMemoryBarrier depthBarrier; VulkanResourceManager *GetResourceManager() { return m_ResourceManager; } VulkanResourceManager *m_ResourceManager; diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index 5c62c4368..27c8916d9 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/renderdoc/driver/vulkan/vk_resources.h @@ -531,12 +531,12 @@ template<> inline void SetTableIfDispatchable(bool writing, VkDevice parent, Wra bool IsDispatchableRes(WrappedVkRes *ptr); VkResourceType IdentifyTypeByPtr(WrappedVkRes *ptr); -#define UNTRANSITIONED_IMG_STATE ((VkImageLayout)0xffffffff) +#define UNKNOWN_PREV_IMG_LAYOUT ((VkImageLayout)0xffffffff) struct ImageRegionState { ImageRegionState() - : oldLayout(UNTRANSITIONED_IMG_STATE), newLayout(UNTRANSITIONED_IMG_STATE) + : oldLayout(UNKNOWN_PREV_IMG_LAYOUT), newLayout(UNKNOWN_PREV_IMG_LAYOUT) { subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subresourceRange.baseArrayLayer = 0; subresourceRange.arraySize = 0; @@ -606,7 +606,7 @@ struct CmdBufferRecordingInfo VkDevice device; VkCmdBufferCreateInfo createInfo; - vector< pair > imgtransitions; + vector< pair > imgbarriers; // sparse resources referenced by this command buffer (at submit time // need to go through the sparse mapping and reference all memory) @@ -689,7 +689,7 @@ struct VkResourceRecord : public ResourceRecord SwapChunks(bakedCommands); cmdInfo->dirtied.swap(bakedCommands->cmdInfo->dirtied); cmdInfo->boundDescSets.swap(bakedCommands->cmdInfo->boundDescSets); - cmdInfo->imgtransitions.swap(bakedCommands->cmdInfo->imgtransitions); + cmdInfo->imgbarriers.swap(bakedCommands->cmdInfo->imgbarriers); cmdInfo->subcmds.swap(bakedCommands->cmdInfo->subcmds); cmdInfo->sparse.swap(bakedCommands->cmdInfo->sparse); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index eb38d3738..9654beb9d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -763,7 +763,7 @@ void WrappedVulkan::vkCmdExecuteCommands( record->cmdInfo->boundDescSets.insert(execRecord->bakedCommands->cmdInfo->boundDescSets.begin(), execRecord->bakedCommands->cmdInfo->boundDescSets.end()); record->cmdInfo->subcmds.push_back(execRecord); - GetResourceManager()->MergeTransitions(record->cmdInfo->imgtransitions, execRecord->bakedCommands->cmdInfo->imgtransitions); + GetResourceManager()->MergeBarriers(record->cmdInfo->imgbarriers, execRecord->bakedCommands->cmdInfo->imgbarriers); } } } @@ -1569,7 +1569,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( SERIALISE_ELEMENT(uint32_t, memCount, memBarrierCount); vector mems; - vector imTrans; + vector imBarriers; for(uint32_t i=0; i < memCount; i++) { @@ -1600,7 +1600,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( if(m_State < WRITING && barrier.image != VK_NULL_HANDLE) { mems.push_back((VkGenericStruct *)new VkImageMemoryBarrier(barrier)); - imTrans.push_back(barrier); + imBarriers.push_back(barrier); } } } @@ -1613,7 +1613,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( ObjDisp(cmdBuffer)->CmdPipelineBarrier(Unwrap(cmdBuffer), src, dest, region, (uint32_t)mems.size(), (const void **)&mems[0]); ResourceId cmd = GetResID(PartialCmdBuf()); - GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } } else if(m_State == READING) @@ -1623,7 +1623,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( ObjDisp(cmdBuffer)->CmdPipelineBarrier(Unwrap(cmdBuffer), src, dest, region, (uint32_t)mems.size(), (const void **)&mems[0]); ResourceId cmd = GetResID(cmdBuffer); - GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } for(size_t i=0; i < mems.size(); i++) @@ -1695,20 +1695,20 @@ void WrappedVulkan::vkCmdPipelineBarrier( record->AddChunk(scope.Get()); - vector imTrans; + vector imBarriers; for(uint32_t i=0; i < memBarrierCount; i++) { VkStructureType stype = ((VkGenericStruct *)ppMemBarriers[i])->sType; if(stype == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) - imTrans.push_back(*((VkImageMemoryBarrier *)ppMemBarriers[i])); + imBarriers.push_back(*((VkImageMemoryBarrier *)ppMemBarriers[i])); } ResourceId cmd = GetResID(cmdBuffer); { SCOPED_LOCK(m_ImageLayoutsLock); - GetResourceManager()->RecordTransitions(GetRecord(cmdBuffer)->cmdInfo->imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(GetRecord(cmdBuffer)->cmdInfo->imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } } } diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 6d28f7b78..3502e9713 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -184,7 +184,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( for(uint32_t i=0; i < numCmds; i++) { ResourceId cmd = GetResourceManager()->GetLiveID(cmdIds[i]); - GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts); + GetResourceManager()->ApplyBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts); } AddEvent(QUEUE_SUBMIT, desc); @@ -299,7 +299,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( for(uint32_t i=0; i < trimmedCmdIds.size(); i++) { ResourceId cmd = trimmedCmdIds[i]; - GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts); + GetResourceManager()->ApplyBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts); } } else @@ -309,7 +309,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( for(uint32_t i=0; i < numCmds; i++) { ResourceId cmd = GetResourceManager()->GetLiveID(cmdIds[i]); - GetResourceManager()->ApplyTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts); + GetResourceManager()->ApplyBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts); } } } @@ -359,7 +359,7 @@ VkResult WrappedVulkan::vkQueueSubmit( { SCOPED_LOCK(m_ImageLayoutsLock); - GetResourceManager()->ApplyTransitions(record->cmdInfo->imgtransitions, m_ImageLayouts); + GetResourceManager()->ApplyBarriers(record->cmdInfo->imgbarriers, m_ImageLayouts); } // need to lock the whole section of code, not just the check on diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index 8b038d614..2fba69ca9 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -1080,12 +1080,12 @@ bool WrappedVulkan::Serialise_vkCreateImage( if(!IsDepthStencilFormat(info.format)) { - range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; layouts.subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } else { - range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); - range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;layouts.subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; layouts.subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;layouts.subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } } } @@ -1194,12 +1194,12 @@ VkResult WrappedVulkan::vkCreateImage( layout->subresourceStates.clear(); if(!IsDepthStencilFormat(pCreateInfo->format)) { - range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; layout->subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; layout->subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } else { - range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; layout->subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); - range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;layout->subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; layout->subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); + range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;layout->subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } } diff --git a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp index a630dff90..fa3e66475 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp @@ -686,7 +686,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( SERIALISE_ELEMENT(uint32_t, memCount, memBarrierCount); vector mems; - vector imTrans; + vector imBarriers; for(uint32_t i=0; i < memCount; i++) { @@ -717,7 +717,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( if(m_State < WRITING && barrier.image != VK_NULL_HANDLE) { mems.push_back((VkGenericStruct *)new VkImageMemoryBarrier(barrier)); - imTrans.push_back(barrier); + imBarriers.push_back(barrier); } } } @@ -747,7 +747,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( m_CleanupEvents.push_back(ev); ResourceId cmd = GetResID(PartialCmdBuf()); - GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } } else if(m_State == READING) @@ -771,7 +771,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( m_CleanupEvents.push_back(ev); ResourceId cmd = GetResID(cmdBuffer); - GetResourceManager()->RecordTransitions(m_BakedCmdBufferInfo[cmd].imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } for(size_t i=0; i < mems.size(); i++) @@ -845,20 +845,20 @@ void WrappedVulkan::vkCmdWaitEvents( SCOPED_SERIALISE_CONTEXT(CMD_WAIT_EVENTS); Serialise_vkCmdWaitEvents(localSerialiser, cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers); - vector imTrans; + vector imBarriers; for(uint32_t i=0; i < memBarrierCount; i++) { VkStructureType stype = ((VkGenericStruct *)ppMemBarriers[i])->sType; if(stype == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) - imTrans.push_back(*((VkImageMemoryBarrier *)ppMemBarriers[i])); + imBarriers.push_back(*((VkImageMemoryBarrier *)ppMemBarriers[i])); } ResourceId cmd = GetResID(cmdBuffer); { SCOPED_LOCK(m_ImageLayoutsLock); - GetResourceManager()->RecordTransitions(GetRecord(cmdBuffer)->cmdInfo->imgtransitions, m_ImageLayouts, (uint32_t)imTrans.size(), &imTrans[0]); + GetResourceManager()->RecordBarriers(GetRecord(cmdBuffer)->cmdInfo->imgbarriers, m_ImageLayouts, (uint32_t)imBarriers.size(), &imBarriers[0]); } record->AddChunk(scope.Get()); diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index c6762e8f0..96789419d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -250,7 +250,7 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR( swapinfo.images[i].im = im; - // fill out image info so we track resource state transitions + // fill out image info so we track resource state barriers // sneaky-cheeky use of the swapchain's ID here (it's not a live ID because // we don't create a live swapchain). This will be picked up in // Serialise_vkGetSwapchainImagesKHR to set the data for the live IDs on the @@ -276,7 +276,7 @@ bool WrappedVulkan::Serialise_vkCreateSwapchainKHR( range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; m_ImageLayouts[liveId].subresourceStates.clear(); - m_ImageLayouts[liveId].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + m_ImageLayouts[liveId].subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } } @@ -400,11 +400,11 @@ VkResult WrappedVulkan::vkCreateSwapchainKHR( range.arraySize = pCreateInfo->imageArraySize; range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - // fill out image info so we track resource state transitions + // fill out image info so we track resource state barriers { SCOPED_LOCK(m_ImageLayoutsLock); m_ImageLayouts[imid].subresourceStates.clear(); - m_ImageLayouts[imid].subresourceStates.push_back(ImageRegionState(range, UNTRANSITIONED_IMG_STATE, VK_IMAGE_LAYOUT_UNDEFINED)); + m_ImageLayouts[imid].subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED)); } {