lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-09-10 07:45:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename 'transitions' to image barriers/layout updates

Browse Source
This commit is contained in:
baldurk
2016-02-07 18:46:25 +01:00
parent c0e7153fa5
commit 68f4d9d27a
14 changed files with 258 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/vk_core.cpp
+15 -15
View File
@@ -560,14 +560,14 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState)
return true;
}
vector<VkImageMemoryBarrier> imgTransitions;
vector<VkImageMemoryBarrier> 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<void *> 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);
renderdoc/driver/vulkan/vk_core.h
+1 -1
View File
@@ -238,7 +238,7 @@ private:
vector<FetchAPIEvent> curEvents;
list<DrawcallTreeNode *> drawStack;
vector< pair<ResourceId, ImageRegionState> > imgtransitions;
vector< pair<ResourceId, ImageRegionState> > 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
renderdoc/driver/vulkan/vk_debug.cpp
+13 -13
View File
@@ -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,
renderdoc/driver/vulkan/vk_initstate.cpp
+31 -31
View File
@@ -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<VkImage>(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, dstBuf, 1, &region);
// 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, &region);
// 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<VkImage>(live), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
1, &region);
// 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|
renderdoc/driver/vulkan/vk_manager.cpp
+82 -82
View File
@@ -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<typename SrcTransType>
void VulkanResourceManager::RecordSingleTransition(vector< pair<ResourceId, ImageRegionState> > &dsttrans, ResourceId id, const SrcTransType &t, uint32_t nummips, uint32_t numslices)
template<typename SrcBarrierType>
void VulkanResourceManager::RecordSingleBarrier(vector< pair<ResourceId, ImageRegionState> > &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< pair<ResourceId, Imag
// verify
//RDCASSERT(it->second.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< pair<ResourceId, Imag
}
else
{
// this handles the case where the transition covers a number of subresources and we need
// to transition each matching subresource. If the transition was only one mip & array slice
// it would have hit the case above. Find each subresource within the range, transition it,
// this handles the case where the barrier covers a number of subresources and we need
// to update each matching subresource. If the barrier was only one mip & array slice
// it would have hit the case above. Find each subresource within the range, update it,
// and continue (marking as done so whenever we stop finding matching ranges, we are
// satisfied.
//
@@ -107,8 +107,8 @@ void VulkanResourceManager::RecordSingleTransition(vector< pair<ResourceId, Imag
it->second.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< pair<ResourceId, Imag
continue;
}
// finally handle the case where we have a range that covers a whole image but we need to
// split it. If the transition covered the whole image too it would have hit the very first
// case, so we know that the transition doesn't cover the whole range.
// split it. If the barrier covered the whole image too it would have hit the very first
// case, so we know that the barrier doesn't cover the whole range.
// Also, if we've already done the split this case won't be hit and we'll either fall into
// the case above, or we'll finish as we've covered the whole transition.
// the case above, or we'll finish as we've covered the whole barrier.
else if(it->second.subresourceRange.mipLevels > 1 || it->second.subresourceRange.arraySize > 1)
{
pair<ResourceId, ImageRegionState> 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< pair<ResourceId, Imag
}
// reset the iterator to point to the first subresource
it = dsttrans.begin()+offs;
it = dststates.begin()+offs;
// the loop will continue after this point and look at the next subresources
// so we need to check to see if the first subresource lies in the range here
@@ -158,8 +158,8 @@ void VulkanResourceManager::RecordSingleTransition(vector< pair<ResourceId, Imag
it->second.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<ResourceId, Imag
if(done) return;
// we don't have an existing transition for this memory region, insert into place. it points to
// we don't have an existing barrier for this memory region, insert into place. it points to
// where it should be inserted
dsttrans.insert(it, std::make_pair(id, ImageRegionState(t.subresourceRange, t.oldLayout, t.newLayout)));
dststates.insert(it, std::make_pair(id, ImageRegionState(t.subresourceRange, t.oldLayout, t.newLayout)));
}
void VulkanResourceManager::RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states,
uint32_t numTransitions, const VkImageMemoryBarrier *transitions)
void VulkanResourceManager::RecordBarriers(vector< pair<ResourceId, ImageRegionState> > &states, map<ResourceId, ImageLayouts> &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<ResourceId, ImageRegionState> > &dsttrans,
vector< pair<ResourceId, ImageRegionState> > &srctrans)
void VulkanResourceManager::MergeBarriers(vector< pair<ResourceId, ImageRegionState> > &dststates,
vector< pair<ResourceId, ImageRegionState> > &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<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &transitions)
void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &barriers)
{
Serialiser *localSerialiser = m_pSerialiser;
@@ -253,7 +253,7 @@ void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImageLayouts> &
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<ResourceId, ImageLayouts> &
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<ResourceId, ImageLayouts> &
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<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states)
void VulkanResourceManager::ApplyBarriers(vector< pair<ResourceId, ImageRegionState> > &states, map<ResourceId, ImageLayouts> &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< pair<ResourceId, ImageRegio
it->range.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< pair<ResourceId, ImageRegio
it->subresourceRange.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< pair<ResourceId, ImageRegio
}
else
{
// this handles the case where the transition covers a number of subresources and we need
// to transition each matching subresource. If the transition was only one mip & array slice
// it would have hit the case above. Find each subresource within the range, transition it,
// this handles the case where the barrier covers a number of subresources and we need
// to update each matching subresource. If the barrier was only one mip & array slice
// it would have hit the case above. Find each subresource within the range, update it,
// and continue (marking as done so whenever we stop finding matching ranges, we are
// satisfied.
//
@@ -397,8 +397,8 @@ void VulkanResourceManager::ApplyTransitions(vector< pair<ResourceId, ImageRegio
it->subresourceRange.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< pair<ResourceId, ImageRegio
continue;
}
// finally handle the case where we have a range that covers a whole image but we need to
// split it. If the transition covered the whole image too it would have hit the very first
// case, so we know that the transition doesn't cover the whole range.
// split it. If the barrier covered the whole image too it would have hit the very first
// case, so we know that the barrier doesn't cover the whole range.
// Also, if we've already done the split this case won't be hit and we'll either fall into
// the case above, or we'll finish as we've covered the whole transition.
// the case above, or we'll finish as we've covered the whole barrier.
else if(it->subresourceRange.mipLevels > 1 || it->subresourceRange.arraySize > 1)
{
ImageRegionState existing = *it;
@@ -448,8 +448,8 @@ void VulkanResourceManager::ApplyTransitions(vector< pair<ResourceId, ImageRegio
it->subresourceRange.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<ResourceId, ImageRegio
}
if(!done)
RDCERR("Couldn't find subresource range to apply transition to - invalid!");
RDCERR("Couldn't find subresource range to apply barrier to - invalid!");
}
}
renderdoc/driver/vulkan/vk_manager.h
+9 -9
View File
@@ -98,19 +98,19 @@ class VulkanResourceManager : public ResourceManager<WrappedVkRes*, TypedRealHan
return realtype( (uint64_t) ((typename UnwrapHelper<realtype>::ParentType *)ResourceManager::GetCurrentResource(id)) );
}
// handling memory & image transitions
template<typename SrcTransType>
void RecordSingleTransition(vector< pair<ResourceId, ImageRegionState> > &trans, ResourceId id, const SrcTransType &t, uint32_t nummips, uint32_t numslices);
// handling memory & image layouts
template<typename SrcBarrierType>
void RecordSingleBarrier(vector< pair<ResourceId, ImageRegionState> > &states, ResourceId id, const SrcBarrierType &t, uint32_t nummips, uint32_t numslices);
void RecordTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states,
uint32_t numTransitions, const VkImageMemoryBarrier *transitions);
void RecordBarriers(vector< pair<ResourceId, ImageRegionState> > &states, map<ResourceId, ImageLayouts> &layouts,
uint32_t numBarriers, const VkImageMemoryBarrier *barriers);
void MergeTransitions(vector< pair<ResourceId, ImageRegionState> > &dsttrans,
vector< pair<ResourceId, ImageRegionState> > &srctrans);
void MergeBarriers(vector< pair<ResourceId, ImageRegionState> > &dststates,
vector< pair<ResourceId, ImageRegionState> > &srcstates);
void ApplyTransitions(vector< pair<ResourceId, ImageRegionState> > &trans, map<ResourceId, ImageLayouts> &states);
void ApplyBarriers(vector< pair<ResourceId, ImageRegionState> > &states, map<ResourceId, ImageLayouts> &layouts);
void SerialiseImageStates(map<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &transitions);
void SerialiseImageStates(map<ResourceId, ImageLayouts> &states, vector<VkImageMemoryBarrier> &barriers);
ResourceId GetID(WrappedVkRes *res)
{
renderdoc/driver/vulkan/vk_replay.cpp
+71 -71
View File
@@ -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, &region);
// 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
renderdoc/driver/vulkan/vk_replay.h
+3 -3
View File
@@ -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;
renderdoc/driver/vulkan/vk_resources.h
+4 -4
View File
@@ -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<ResourceId, ImageRegionState> > imgtransitions;
vector< pair<ResourceId, ImageRegionState> > 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);
}
renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp
+8 -8
View File
@@ -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<VkGenericStruct*> mems;
vector<VkImageMemoryBarrier> imTrans;
vector<VkImageMemoryBarrier> 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<VkImageMemoryBarrier> imTrans;
vector<VkImageMemoryBarrier> 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]);
}
}
}
renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp
+4 -4
View File
@@ -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
renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp
+6 -6
View File
@@ -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));
}
}
renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp
+7 -7
View File
@@ -686,7 +686,7 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents(
SERIALISE_ELEMENT(uint32_t, memCount, memBarrierCount);
vector<VkGenericStruct*> mems;
vector<VkImageMemoryBarrier> imTrans;
vector<VkImageMemoryBarrier> 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<VkImageMemoryBarrier> imTrans;
vector<VkImageMemoryBarrier> 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());
renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp
+4 -4
View File
@@ -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));
}
{