lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-28 01:16:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: Rendering state per command buffer

Browse Source 
This is needed for Vulkan Pixel history, where we need to know render
state at current point of time for a command buffer during callback
replay.

Modifications:
- Removed m_pDriver and m_CreationInfo members from VulkanRenderState,
instead these are accepted as arguments to member functions.
- BakedCmdBufferInfo state is now full VulkanRenderState
This commit is contained in:
Aliya Pazylbekova
2020-02-28 11:38:10 +00:00
committed by Baldur Karlsson
parent da17ebed57
commit ef2804bfd3
14 changed files with 529 additions and 482 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/vk_bindless_feedback.cpp
+2 -2
View File
@@ -820,14 +820,14 @@ void VulkanReplay::FetchShaderFeedback(uint32_t eventId)
if(result.compute)
{
modifiedstate.BindPipeline(cmd, VulkanRenderState::BindCompute, true);
modifiedstate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindCompute, true);
ObjDisp(cmd)->CmdDispatch(Unwrap(cmd), drawcall->dispatchDimension[0],
drawcall->dispatchDimension[1], drawcall->dispatchDimension[2]);
}
else
{
modifiedstate.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
modifiedstate.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics);
if(drawcall->flags & DrawFlags::Indexed)
{
renderdoc/driver/vulkan/vk_core.cpp
+42 -25
View File
@@ -93,7 +93,7 @@ void VkInitParams::Set(const VkInstanceCreateInfo *pCreateInfo, ResourceId inst)
InstanceID = inst;
}
WrappedVulkan::WrappedVulkan() : m_RenderState(this, &m_CreationInfo)
WrappedVulkan::WrappedVulkan()
{
if(RenderDoc::Inst().GetCrashHandler())
RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this, sizeof(WrappedVulkan));
@@ -2492,6 +2492,11 @@ ReplayStatus WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t sta
if(!partial && !IsStructuredExporting(m_State))
AddFrameTerminator(AMDRGPControl::GetEndTag());
if(m_Partial[Secondary].partialParent != ResourceId())
m_RenderState = m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state;
else if(m_Partial[Primary].partialParent != ResourceId())
m_RenderState = m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state;
// swap the structure back now that we've accumulated the frame as well.
if(IsLoading(m_State) || IsStructuredExporting(m_State))
ser.GetStructuredFile().Swap(*prevFile);
@@ -3139,7 +3144,16 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay
{
m_Partial[Primary].Reset();
m_Partial[Secondary].Reset();
m_RenderState = VulkanRenderState(this, &m_CreationInfo);
m_RenderState = VulkanRenderState();
for(auto it = m_BakedCmdBufferInfo.begin(); it != m_BakedCmdBufferInfo.end(); it++)
it->second.state = VulkanRenderState();
}
else
{
if(m_Partial[Secondary].partialParent != ResourceId())
m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state = m_RenderState;
else if(m_Partial[Primary].partialParent != ResourceId())
m_BakedCmdBufferInfo[m_Partial[Primary].partialParent].state = m_RenderState;
}
VkResult vkr = VK_SUCCESS;
@@ -3187,13 +3201,13 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay
// if a render pass was active, begin it and set up the partial replay state
m_RenderState.BeginRenderPassAndApplyState(
cmd, rpUnneeded ? VulkanRenderState::BindNone : VulkanRenderState::BindGraphics);
this, cmd, rpUnneeded ? VulkanRenderState::BindNone : VulkanRenderState::BindGraphics);
}
else
{
// even outside of render passes, we need to restore the state
m_RenderState.BindPipeline(cmd, VulkanRenderState::BindCompute, false);
m_RenderState.BindPipeline(cmd, VulkanRenderState::BindGraphics, false);
m_RenderState.BindPipeline(this, cmd, VulkanRenderState::BindCompute, false);
m_RenderState.BindPipeline(this, cmd, VulkanRenderState::BindGraphics, false);
}
}
@@ -3216,7 +3230,7 @@ void WrappedVulkan::ReplayLog(uint32_t startEventID, uint32_t endEventID, Replay
// end any active XFB
if(!m_RenderState.xfbcounters.empty())
m_RenderState.EndTransformFeedback(cmd);
m_RenderState.EndTransformFeedback(this, cmd);
// end any active conditional rendering
if(m_RenderState.IsConditionalRenderingEnabled())
@@ -3662,20 +3676,21 @@ void WrappedVulkan::AddDrawcall(const DrawcallDescription &d, bool hasEvents)
if(m_LastCmdBufferID != ResourceId())
{
ResourceId pipe = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.pipeline;
ResourceId pipe = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.pipeline;
if(pipe != ResourceId())
draw.topology = MakePrimitiveTopology(m_CreationInfo.m_Pipeline[pipe].topology,
m_CreationInfo.m_Pipeline[pipe].patchControlPoints);
draw.indexByteWidth = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth;
draw.indexByteWidth = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth;
ResourceId fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer;
ResourceId fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebuffer();
ResourceId rp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass;
uint32_t sp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass;
if(fb != ResourceId() && rp != ResourceId())
{
rdcarray<ResourceId> &atts = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments;
const rdcarray<ResourceId> &atts =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments();
RDCASSERT(sp < m_CreationInfo.m_RenderPass[rp].subpasses.size());
@@ -3747,7 +3762,7 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarray<DebugMes
{
DrawcallDescription &d = drawNode.draw;
const BakedCmdBufferInfo::CmdBufferState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state;
const VulkanRenderState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state;
VulkanCreationInfo &c = m_CreationInfo;
uint32_t e = d.eventId;
@@ -3758,26 +3773,26 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarray<DebugMes
//////////////////////////////
// Vertex input
if(d.flags & DrawFlags::Indexed && state.ibuffer != ResourceId())
if(d.flags & DrawFlags::Indexed && state.ibuffer.buf != ResourceId())
drawNode.resourceUsage.push_back(
make_rdcpair(state.ibuffer, EventUsage(e, ResourceUsage::IndexBuffer)));
make_rdcpair(state.ibuffer.buf, EventUsage(e, ResourceUsage::IndexBuffer)));
for(size_t i = 0; i < state.vbuffers.size(); i++)
{
if(state.vbuffers[i] != ResourceId())
if(state.vbuffers[i].buf != ResourceId())
{
drawNode.resourceUsage.push_back(
make_rdcpair(state.vbuffers[i], EventUsage(e, ResourceUsage::VertexBuffer)));
make_rdcpair(state.vbuffers[i].buf, EventUsage(e, ResourceUsage::VertexBuffer)));
}
}
for(uint32_t i = state.xfbfirst;
i < state.xfbfirst + state.xfbcount && i < state.xfbbuffers.size(); i++)
for(uint32_t i = state.firstxfbcounter;
i < state.firstxfbcounter + state.xfbcounters.size() && i < state.xfbbuffers.size(); i++)
{
if(state.xfbbuffers[i] != ResourceId())
if(state.xfbbuffers[i].buf != ResourceId())
{
drawNode.resourceUsage.push_back(
make_rdcpair(state.xfbbuffers[i], EventUsage(e, ResourceUsage::StreamOut)));
make_rdcpair(state.xfbbuffers[i].buf, EventUsage(e, ResourceUsage::StreamOut)));
}
}
@@ -3786,16 +3801,18 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarray<DebugMes
for(int shad = 0; shad < 6; shad++)
{
VulkanCreationInfo::Pipeline::Shader &sh = c.m_Pipeline[state.pipeline].shaders[shad];
bool compute = (shad == 5);
ResourceId pipe = (compute ? state.compute.pipeline : state.graphics.pipeline);
VulkanCreationInfo::Pipeline::Shader &sh = c.m_Pipeline[pipe].shaders[shad];
if(sh.module == ResourceId())
continue;
ResourceId origPipe = GetResourceManager()->GetOriginalID(state.pipeline);
ResourceId origPipe = GetResourceManager()->GetOriginalID(pipe);
ResourceId origShad = GetResourceManager()->GetOriginalID(sh.module);
// 5 is the compute shader's index (VS, TCS, TES, GS, FS, CS)
const rdcarray<BakedCmdBufferInfo::CmdBufferState::DescriptorAndOffsets> &descSets =
(shad == 5 ? state.computeDescSets : state.graphicsDescSets);
const rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descSets =
(compute ? state.compute.descSets : state.graphics.descSets);
RDCASSERT(sh.mapping);
@@ -3923,8 +3940,8 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, rdcarray<DebugMes
//////////////////////////////
// Framebuffer/renderpass
AddFramebufferUsage(drawNode, state.renderPass, state.framebuffer, state.subpass,
state.fbattachments);
AddFramebufferUsage(drawNode, state.renderPass, state.GetFramebuffer(), state.subpass,
state.GetFramebufferAttachments());
}
void WrappedVulkan::AddFramebufferUsage(VulkanDrawcallTreeNode &drawNode, ResourceId renderPass,
renderdoc/driver/vulkan/vk_core.h
+9 -23
View File
@@ -551,29 +551,7 @@ private:
rdcarray<rdcpair<ResourceId, EventUsage>> resourceUsage;
struct CmdBufferState
{
ResourceId pipeline;
struct DescriptorAndOffsets
{
ResourceId descSet;
rdcarray<uint32_t> offsets;
};
rdcarray<DescriptorAndOffsets> graphicsDescSets, computeDescSets;
uint32_t idxWidth = 0;
ResourceId ibuffer;
rdcarray<ResourceId> vbuffers;
rdcarray<ResourceId> xfbbuffers;
uint32_t xfbfirst = 0;
uint32_t xfbcount = 0;
ResourceId renderPass;
ResourceId framebuffer;
rdcarray<ResourceId> fbattachments;
uint32_t subpass = 0;
} state;
VulkanRenderState state;
std::map<ResourceId, ImageState> imageStates;
@@ -941,6 +919,14 @@ public:
return record ? *record->instDevInfo : m_EnabledExtensions;
}
VulkanRenderState &GetCmdRenderState()
{
RDCASSERT(m_LastCmdBufferID != ResourceId());
auto it = m_BakedCmdBufferInfo.find(m_LastCmdBufferID);
RDCASSERT(it != m_BakedCmdBufferInfo.end());
return it->second.state;
}
static rdcstr GetChunkName(uint32_t idx);
VulkanResourceManager *GetResourceManager() { return m_ResourceManager; }
VulkanDebugManager *GetDebugManager() { return m_DebugManager; }
renderdoc/driver/vulkan/vk_debug.cpp
+50 -1
View File
@@ -1473,13 +1473,62 @@ uint32_t VulkanReplay::PickVertex(uint32_t eventId, int32_t w, int32_t h, const
return ret;
}
const VulkanCreationInfo::Image &VulkanDebugManager::GetImageInfo(ResourceId img)
const VulkanCreationInfo::Image &VulkanDebugManager::GetImageInfo(ResourceId img) const
{
auto it = m_pDriver->m_CreationInfo.m_Image.find(img);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_Image.end());
return it->second;
}
const VulkanCreationInfo::Pipeline &VulkanDebugManager::GetPipelineInfo(ResourceId pipe) const
{
auto it = m_pDriver->m_CreationInfo.m_Pipeline.find(pipe);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_Pipeline.end());
return it->second;
}
const VulkanCreationInfo::ShaderModule &VulkanDebugManager::GetShaderInfo(ResourceId shader) const
{
auto it = m_pDriver->m_CreationInfo.m_ShaderModule.find(shader);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_ShaderModule.end());
return it->second;
}
const VulkanCreationInfo::Framebuffer &VulkanDebugManager::GetFramebufferInfo(ResourceId fb) const
{
auto it = m_pDriver->m_CreationInfo.m_Framebuffer.find(fb);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_Framebuffer.end());
return it->second;
}
const VulkanCreationInfo::RenderPass &VulkanDebugManager::GetRenderPassInfo(ResourceId rp) const
{
auto it = m_pDriver->m_CreationInfo.m_RenderPass.find(rp);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_RenderPass.end());
return it->second;
}
const VulkanCreationInfo::PipelineLayout &VulkanDebugManager::GetPipelineLayoutInfo(ResourceId rp) const
{
auto it = m_pDriver->m_CreationInfo.m_PipelineLayout.find(rp);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_PipelineLayout.end());
return it->second;
}
const DescSetLayout &VulkanDebugManager::GetDescSetLayout(ResourceId dsl) const
{
auto it = m_pDriver->m_CreationInfo.m_DescSetLayout.find(dsl);
RDCASSERT(it != m_pDriver->m_CreationInfo.m_DescSetLayout.end());
return it->second;
}
const WrappedVulkan::DescriptorSetInfo &VulkanDebugManager::GetDescSetInfo(ResourceId ds) const
{
auto it = m_pDriver->m_DescriptorSetState.find(ds);
RDCASSERT(it != m_pDriver->m_DescriptorSetState.end());
return it->second;
}
void VulkanDebugManager::GetBufferData(ResourceId buff, uint64_t offset, uint64_t len, bytebuf &ret)
{
VkDevice dev = m_pDriver->GetDev();
renderdoc/driver/vulkan/vk_debug.h
+8 -1
View File
@@ -89,7 +89,14 @@ public:
VkImageLayout GetImageLayout(ResourceId image, VkImageAspectFlagBits aspect, uint32_t mip,
uint32_t slice);
const VulkanCreationInfo::Image &GetImageInfo(ResourceId img);
const VulkanCreationInfo::Image &GetImageInfo(ResourceId img) const;
const VulkanCreationInfo::Pipeline &GetPipelineInfo(ResourceId pipe) const;
const VulkanCreationInfo::ShaderModule &GetShaderInfo(ResourceId shader) const;
const VulkanCreationInfo::Framebuffer &GetFramebufferInfo(ResourceId fb) const;
const VulkanCreationInfo::RenderPass &GetRenderPassInfo(ResourceId rp) const;
const VulkanCreationInfo::PipelineLayout &GetPipelineLayoutInfo(ResourceId pp) const;
const DescSetLayout &GetDescSetLayout(ResourceId dsl) const;
const WrappedVulkan::DescriptorSetInfo &GetDescSetInfo(ResourceId ds) const;
private:
// GetBufferData
renderdoc/driver/vulkan/vk_overlay.cpp
+24 -24
View File
@@ -43,11 +43,7 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
{
VulkanQuadOverdrawCallback(WrappedVulkan *vk, VkDescriptorSetLayout descSetLayout,
VkDescriptorSet descSet, const rdcarray<uint32_t> &events)
: m_pDriver(vk),
m_DescSetLayout(descSetLayout),
m_DescSet(descSet),
m_Events(events),
m_PrevState(vk, NULL)
: m_pDriver(vk), m_DescSetLayout(descSetLayout), m_DescSet(descSet), m_Events(events)
{
m_pDriver->SetDrawcallCB(this);
}
@@ -63,8 +59,8 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
VkResult vkr = VK_SUCCESS;
m_PrevState = m_pDriver->GetRenderState();
VulkanRenderState &pipestate = m_pDriver->GetRenderState();
m_PrevState = m_pDriver->GetCmdRenderState();
VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState();
// check cache first
CachedPipeline pipe = m_PipelineCache[pipestate.graphics.pipeline];
@@ -72,25 +68,26 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
// if we don't get a hit, create a modified pipeline
if(pipe.pipe == VK_NULL_HANDLE)
{
VulkanCreationInfo &c = *pipestate.m_CreationInfo;
VulkanCreationInfo::Pipeline &p = c.m_Pipeline[pipestate.graphics.pipeline];
const VulkanCreationInfo::Pipeline &p =
m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline);
VkDescriptorSetLayout *descSetLayouts;
// descSet will be the index of our new descriptor set
uint32_t descSet = (uint32_t)c.m_PipelineLayout[p.layout].descSetLayouts.size();
uint32_t descSet =
(uint32_t)m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).descSetLayouts.size();
descSetLayouts = new VkDescriptorSetLayout[descSet + 1];
for(uint32_t i = 0; i < descSet; i++)
descSetLayouts[i] = m_pDriver->GetResourceManager()->GetCurrentHandle<VkDescriptorSetLayout>(
c.m_PipelineLayout[p.layout].descSetLayouts[i]);
m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).descSetLayouts[i]);
// this layout has storage image and
descSetLayouts[descSet] = m_DescSetLayout;
const rdcarray<VkPushConstantRange> &push = c.m_PipelineLayout[p.layout].pushRanges;
const rdcarray<VkPushConstantRange> &push =
m_pDriver->GetDebugManager()->GetPipelineLayoutInfo(p.layout).pushRanges;
VkPipelineLayoutCreateInfo pipeLayoutInfo = {
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
@@ -222,7 +219,7 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
pipestate.graphics.descSets[pipe.descSet].descSet = GetResID(m_DescSet);
if(cmd)
pipestate.BindPipeline(cmd, VulkanRenderState::BindGraphics, false);
pipestate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics, false);
}
bool PostDraw(uint32_t eid, VkCommandBuffer cmd)
@@ -231,10 +228,11 @@ struct VulkanQuadOverdrawCallback : public VulkanDrawcallCallback
return false;
// restore the render state and go ahead with the real draw
m_pDriver->GetRenderState() = m_PrevState;
m_pDriver->GetCmdRenderState() = m_PrevState;
RDCASSERT(cmd);
m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false);
m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics,
false);
return true;
}
@@ -838,7 +836,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
// modify state
m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP);
m_pDriver->m_RenderState.subpass = 0;
m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.graphics.pipeline = GetResID(pipe);
@@ -871,7 +869,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
RDCASSERTEQUAL(vkr, VK_SUCCESS);
// do single draw
m_pDriver->m_RenderState.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd,
VulkanRenderState::BindGraphics);
ObjDisp(cmd)->CmdDrawIndexed(Unwrap(cmd), patchedIndexCount, mainDraw->numInstances, 0, 0,
mainDraw->instanceOffset);
m_pDriver->m_RenderState.EndRenderPass(cmd);
@@ -1179,7 +1178,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
// modify state
m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP);
m_pDriver->m_RenderState.subpass = 0;
m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.graphics.pipeline = GetResID(pipe[0]);
@@ -1472,7 +1471,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
// modify state
m_pDriver->m_RenderState.renderPass = GetResID(m_Overlay.NoDepthRP);
m_pDriver->m_RenderState.subpass = 0;
m_pDriver->m_RenderState.SetFramebuffer(GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(m_Overlay.NoDepthFB));
m_pDriver->m_RenderState.graphics.pipeline = GetResID(failpipe);
@@ -1494,7 +1493,7 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
if(depthRP != VK_NULL_HANDLE)
{
m_pDriver->m_RenderState.renderPass = GetResID(depthRP);
m_pDriver->m_RenderState.SetFramebuffer(GetResID(depthFB));
m_pDriver->m_RenderState.SetFramebuffer(m_pDriver, GetResID(depthFB));
}
m_pDriver->ReplayLog(0, eventId, eReplay_OnlyDraw);
@@ -1598,7 +1597,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
vkr = vt->BeginCommandBuffer(Unwrap(cmd), &beginInfo);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
m_pDriver->m_RenderState.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
m_pDriver->m_RenderState.BeginRenderPassAndApplyState(m_pDriver, cmd,
VulkanRenderState::BindGraphics);
VkClearAttachment clearatt = {VK_IMAGE_ASPECT_COLOR_BIT, 0, {}};
memcpy(clearatt.clearValue.color.float32, &clearCol, sizeof(clearatt.clearValue.color.float32));
@@ -1653,11 +1653,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, CompType typeCast, Floa
vkr = vt->EndCommandBuffer(Unwrap(cmd));
RDCASSERTEQUAL(vkr, VK_SUCCESS);
for(size_t i = startEvent; i < events.size(); i++)
for (size_t i = startEvent; i < events.size(); i++)
{
m_pDriver->ReplayLog(events[i], events[i], eReplay_OnlyDraw);
if(overlay == DebugOverlay::ClearBeforePass && i + 1 < events.size())
if (overlay == DebugOverlay::ClearBeforePass && i + 1 < events.size())
m_pDriver->ReplayLog(events[i] + 1, events[i + 1], eReplay_WithoutDraw);
}
renderdoc/driver/vulkan/vk_pixelhistory.cpp
+30 -32
View File
@@ -160,7 +160,7 @@ private:
VkShaderModule CreateShaderReplacement(ResourceId shaderId, const rdcstr &entryName)
{
const VulkanCreationInfo::ShaderModule &moduleInfo =
m_pDriver->GetRenderState().m_CreationInfo->m_ShaderModule[shaderId];
m_pDriver->GetDebugManager()->GetShaderInfo(shaderId);
rdcarray<uint32_t> modSpirv = moduleInfo.spirv.GetSPIRV();
rdcspv::Editor editor(modSpirv);
editor.Prepare();
@@ -388,8 +388,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
m_DstBuffer(dstBuffer),
m_ColorImageView(colorImageView),
m_StencilImageView(stencilImageView),
m_StencilImage(stencilImage),
m_PrevState(vk, NULL)
m_StencilImage(stencilImage)
{
for(size_t i = 0; i < events.size(); i++)
m_Events.insert(std::make_pair(events[i].eventId, events[i]));
@@ -468,11 +467,12 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
if(it == m_Events.end())
return;
EventUsage event = it->second;
m_PrevState = m_pDriver->GetRenderState();
VulkanRenderState prevState = m_pDriver->GetCmdRenderState();
// TODO: handle secondary command buffers.
// TODO: can't end renderpass if we are not on the last subpass.
m_pDriver->GetRenderState().EndRenderPass(cmd);
m_pDriver->GetCmdRenderState().EndRenderPass(cmd);
// Get pre-modification values
size_t storeOffset = m_EventIndices.size() * sizeof(EventInfo);
VkImage depthImage = VK_NULL_HANDLE;
@@ -488,13 +488,12 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
CopyPixel(m_Image, m_Format, depthImage, depthFormat, cmd, storeOffset);
VulkanRenderState &pipestate = m_pDriver->GetRenderState();
ResourceId prevState = pipestate.graphics.pipeline;
VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState();
ResourceId prevRenderpass = pipestate.renderPass;
ResourceId prevFramebuffer = pipestate.GetFramebuffer();
rdcarray<ResourceId> prevFBattachments = pipestate.GetFramebufferAttachments();
const VulkanCreationInfo::Pipeline &p =
m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipestate.graphics.pipeline];
m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline);
uint32_t prevSubpass = pipestate.subpass;
{
@@ -509,7 +508,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
// the draw. We will get occlusion data to figure out if anything wrote to
// the pixel, as well as number of fragments not accounting for potential
// shader discard.
pipestate.SetFramebuffer(GetResID(m_OffscreenFB));
pipestate.SetFramebuffer(m_pDriver, GetResID(m_OffscreenFB));
pipestate.renderPass = GetResID(m_RenderPass);
pipestate.subpass = 0;
pipestate.graphics.pipeline = GetResID(replacements.fixedShaderStencil);
@@ -544,14 +543,15 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
}
// Restore the state.
m_pDriver->GetRenderState() = m_PrevState;
m_pDriver->GetCmdRenderState() = prevState;
pipestate.SetFramebuffer(prevFramebuffer, prevFBattachments);
pipestate.renderPass = prevRenderpass;
pipestate.subpass = prevSubpass;
// TODO: Need to re-start on the correct subpass.
if(m_PrevState.graphics.pipeline != ResourceId())
m_pDriver->GetRenderState().BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
if(m_pDriver->GetCmdRenderState().graphics.pipeline != ResourceId())
m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd,
VulkanRenderState::BindGraphics);
}
bool PostDraw(uint32_t eid, VkCommandBuffer cmd)
@@ -559,7 +559,7 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
if(m_Events.find(eid) == m_Events.end())
return false;
m_pDriver->GetRenderState().EndRenderPass(cmd);
m_pDriver->GetCmdRenderState().EndRenderPass(cmd);
size_t storeOffset = m_EventIndices.size() * sizeof(EventInfo);
VkImage depthImage = VK_NULL_HANDLE;
@@ -576,7 +576,8 @@ struct VulkanOcclusionAndStencilCallback : public VulkanPixelHistoryCallback
CopyPixel(m_Image, m_Format, depthImage, depthFormat, cmd,
storeOffset + offsetof(struct EventInfo, postmod));
m_pDriver->GetRenderState().BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd,
VulkanRenderState::BindGraphics);
// Get post-modification values
m_EventIndices.insert(std::make_pair(eid, m_EventIndices.size()));
@@ -685,9 +686,9 @@ private:
void ReplayDraw(VkCommandBuffer cmd, size_t eventIndex, int eventId, bool doQuery,
bool clear = false)
{
VulkanRenderState &state = m_pDriver->GetRenderState();
const DrawcallDescription *drawcall = m_pDriver->GetDrawcall(eventId);
state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
m_pDriver->GetCmdRenderState().BeginRenderPassAndApplyState(m_pDriver, cmd,
VulkanRenderState::BindGraphics);
if(clear)
{
@@ -719,7 +720,7 @@ private:
if(doQuery)
ObjDisp(cmd)->CmdEndQuery(Unwrap(cmd), m_OcclusionPool, (uint32_t)eventIndex);
state.EndRenderPass(cmd);
m_pDriver->GetCmdRenderState().EndRenderPass(cmd);
}
// GetPipelineReplacements creates pipeline replacements that disable all tests,
@@ -735,8 +736,7 @@ private:
if(pipeIt != m_PipelineCache.end())
return pipeIt->second;
const VulkanCreationInfo::Pipeline &p =
m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipeline];
const VulkanCreationInfo::Pipeline &p = m_pDriver->GetDebugManager()->GetPipelineInfo(pipeline);
EventFlags eventFlags = m_pDriver->GetEventFlags(eid);
VkShaderModule replacementShaders[5] = {};
@@ -855,8 +855,6 @@ private:
// Key is event ID, and value is an index of where the occlusion result.
std::map<uint32_t, uint32_t> m_OcclusionQueries;
rdcarray<uint64_t> m_OcclusionResults;
VulkanRenderState m_PrevState;
};
// TestsFailedCallback replays draws to figure out which tests failed (for ex., depth,
@@ -876,9 +874,9 @@ struct TestsFailedCallback : public VulkanPixelHistoryCallback
if(!m_Events.contains(eid))
return;
VulkanRenderState &pipestate = m_pDriver->GetRenderState();
VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState();
const VulkanCreationInfo::Pipeline &p =
m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[pipestate.graphics.pipeline];
m_pDriver->GetDebugManager()->GetPipelineInfo(pipestate.graphics.pipeline);
uint32_t eventFlags = CalculateEventFlags(p, pipestate);
m_EventFlags[eid] = eventFlags;
@@ -888,12 +886,13 @@ struct TestsFailedCallback : public VulkanPixelHistoryCallback
m_HasEarlyFragments[eid] = earlyFragmentTests;
ResourceId curPipeline = pipestate.graphics.pipeline;
VulkanRenderState m_PrevState = m_pDriver->GetRenderState();
VulkanRenderState m_PrevState = m_pDriver->GetCmdRenderState();
ReplayDrawWithTests(cmd, eid, eventFlags, curPipeline);
m_pDriver->GetRenderState() = m_PrevState;
m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false);
m_pDriver->GetCmdRenderState() = m_PrevState;
m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics,
false);
}
bool PostDraw(uint32_t eid, VkCommandBuffer cmd) { return false; }
@@ -1085,7 +1084,7 @@ private:
return;
const VulkanCreationInfo::Pipeline &p =
m_pDriver->GetRenderState().m_CreationInfo->m_Pipeline[basePipeline];
m_pDriver->GetDebugManager()->GetPipelineInfo(basePipeline);
EventFlags eventShaderFlags = m_pDriver->GetEventFlags(eid);
uint32_t numberOfStages = 5;
rdcarray<VkShaderModule> replacementShaders;
@@ -1103,7 +1102,7 @@ private:
}
bool dynamicScissor = p.dynamicStates[VkDynamicScissor];
VulkanRenderState &pipestate = m_pDriver->GetRenderState();
VulkanRenderState &pipestate = m_pDriver->GetCmdRenderState();
rdcarray<VkRect2D> prevScissors = pipestate.scissors;
if(dynamicScissor)
for(uint32_t i = 0; i < pipestate.views.size(); i++)
@@ -1275,8 +1274,9 @@ private:
void ReplayDraw(VkCommandBuffer cmd, VkPipeline pipe, int eventId, uint32_t test)
{
m_pDriver->GetRenderState().graphics.pipeline = GetResID(pipe);
m_pDriver->GetRenderState().BindPipeline(cmd, VulkanRenderState::BindGraphics, false);
m_pDriver->GetCmdRenderState().graphics.pipeline = GetResID(pipe);
m_pDriver->GetCmdRenderState().BindPipeline(m_pDriver, cmd, VulkanRenderState::BindGraphics,
false);
uint32_t index = (uint32_t)m_OcclusionQueries.size();
if(m_OcclusionQueries.find(rdcpair<uint32_t, uint32_t>(eventId, test)) != m_OcclusionQueries.end())
@@ -1346,7 +1346,6 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou
RDCASSERTEQUAL(vkr, VK_SUCCESS);
VkImage wrappedColorImage = colorImage;
m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), wrappedColorImage);
ImageState colorImageState = ImageState(wrappedColorImage, ImageInfo(imgInfo), eFrameRef_None);
VkMemoryRequirements colorImageMrq = {0};
@@ -1360,7 +1359,6 @@ bool VulkanDebugManager::PixelHistorySetupResources(PixelHistoryResources &resou
RDCASSERTEQUAL(vkr, VK_SUCCESS);
VkImage wrappedStencilImage = stencilImage;
m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), wrappedStencilImage);
ImageState stencilImageState = ImageState(wrappedStencilImage, ImageInfo(imgInfo), eFrameRef_None);
VkMemoryRequirements stencilImageMrq = {0};
renderdoc/driver/vulkan/vk_postvs.cpp
+16 -14
View File
@@ -1557,9 +1557,8 @@ void VulkanReplay::PatchReservedDescriptors(const VulkanStatePipeline &pipe,
}
}
void VulkanReplay::FetchVSOut(uint32_t eventId)
void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state)
{
const VulkanRenderState &state = m_pDriver->m_RenderState;
VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo;
const VulkanCreationInfo::Pipeline &pipeInfo = creationInfo.m_Pipeline[state.graphics.pipeline];
@@ -1637,7 +1636,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId)
// create a duplicate set of descriptor sets, all visible to compute, with bindings shifted to
// account for new ones we need. This also copies the existing bindings into the new sets
PatchReservedDescriptors(m_pDriver->m_RenderState.graphics, descpool, setLayouts, descSets,
PatchReservedDescriptors(state.graphics, descpool, setLayouts, descSets,
VK_SHADER_STAGE_COMPUTE_BIT, newBindings, ARRAY_COUNT(newBindings));
// create pipeline layout with new descriptor set layouts
@@ -2510,7 +2509,7 @@ void VulkanReplay::FetchVSOut(uint32_t eventId)
m_pDriver->vkUpdateDescriptorSets(dev, 1, &write, 0, NULL);
// do single draw
modifiedstate.BindPipeline(cmd, VulkanRenderState::BindCompute, true);
modifiedstate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindCompute, true);
uint64_t totalVerts = numVerts * uint64_t(drawcall->numInstances) * uint64_t(numViews);
// the validation layers will probably complain about this dispatch saying some arrays aren't
@@ -2705,9 +2704,8 @@ void VulkanReplay::FetchVSOut(uint32_t eventId)
m_pDriver->vkDestroyShaderModule(dev, module, NULL);
}
void VulkanReplay::FetchTessGSOut(uint32_t eventId)
void VulkanReplay::FetchTessGSOut(uint32_t eventId, VulkanRenderState &state)
{
VulkanRenderState state = m_pDriver->m_RenderState;
VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo;
const VulkanCreationInfo::Pipeline &pipeInfo = creationInfo.m_Pipeline[state.graphics.pipeline];
@@ -2873,7 +2871,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId)
RDCASSERTEQUAL(vkr, VK_SUCCESS);
state.graphics.pipeline = GetResID(pipe);
state.SetFramebuffer(GetResID(fb));
state.SetFramebuffer(m_pDriver, GetResID(fb));
state.renderPass = GetResID(rp);
state.subpass = 0;
state.renderArea.offset.x = 0;
@@ -3002,7 +3000,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId)
// wait for the above fill to finish.
DoPipelineBarrier(cmd, 1, &meshbufbarrier);
state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
state.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics);
ObjDisp(cmd)->CmdBeginQuery(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0, 0);
@@ -3064,7 +3062,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId)
ObjDisp(dev)->CmdResetQueryPool(Unwrap(cmd), Unwrap(m_PostVS.XFBQueryPool), 0,
drawcall->numInstances);
state.BeginRenderPassAndApplyState(cmd, VulkanRenderState::BindGraphics);
state.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics);
// do incremental draws to get the output size. We have to do this O(N^2) style because
// there's no way to replay only a single instance. We have to replay 1, 2, 3, ... N
@@ -3250,7 +3248,7 @@ void VulkanReplay::FetchTessGSOut(uint32_t eventId)
m_pDriver->vkDestroyShaderModule(dev, module, NULL);
}
void VulkanReplay::InitPostVSBuffers(uint32_t eventId)
void VulkanReplay::InitPostVSBuffers(uint32_t eventId, VulkanRenderState &state)
{
// go through any aliasing
if(m_PostVS.Alias.find(eventId) != m_PostVS.Alias.end())
@@ -3259,7 +3257,6 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId)
if(m_PostVS.Data.find(eventId) != m_PostVS.Data.end())
return;
const VulkanRenderState &state = m_pDriver->m_RenderState;
VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo;
if(state.graphics.pipeline == ResourceId() || state.renderPass == ResourceId())
@@ -3277,7 +3274,7 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId)
VkMarkerRegion::Begin(StringFormat::Fmt("FetchVSOut for %u", eventId));
FetchVSOut(eventId);
FetchVSOut(eventId, state);
VkMarkerRegion::End();
@@ -3287,11 +3284,16 @@ void VulkanReplay::InitPostVSBuffers(uint32_t eventId)
VkMarkerRegion::Begin(StringFormat::Fmt("FetchTessGSOut for %u", eventId));
FetchTessGSOut(eventId);
FetchTessGSOut(eventId, state);
VkMarkerRegion::End();
}
void VulkanReplay::InitPostVSBuffers(uint32_t eventId)
{
InitPostVSBuffers(eventId, m_pDriver->GetRenderState());
}
struct VulkanInitPostVSCallback : public VulkanDrawcallCallback
{
VulkanInitPostVSCallback(WrappedVulkan *vk, const rdcarray<uint32_t> &events)
@@ -3303,7 +3305,7 @@ struct VulkanInitPostVSCallback : public VulkanDrawcallCallback
void PreDraw(uint32_t eid, VkCommandBuffer cmd)
{
if(m_Events.contains(eid))
m_pDriver->GetReplay()->InitPostVSBuffers(eid);
m_pDriver->GetReplay()->InitPostVSBuffers(eid, m_pDriver->GetCmdRenderState());
}
bool PostDraw(uint32_t eid, VkCommandBuffer cmd) { return false; }
renderdoc/driver/vulkan/vk_replay.h
+4 -2
View File
@@ -29,6 +29,7 @@
#include "replay/replay_driver.h"
#include "vk_common.h"
#include "vk_info.h"
#include "vk_state.h"
#if ENABLED(RDOC_WIN32)
@@ -322,6 +323,7 @@ public:
float maxval, bool channels[4], rdcarray<uint32_t> &histogram);
void InitPostVSBuffers(uint32_t eventId);
void InitPostVSBuffers(uint32_t eventId, VulkanRenderState &state);
void InitPostVSBuffers(const rdcarray<uint32_t> &passEvents);
// indicates that EID alias is the same as eventId
@@ -421,8 +423,8 @@ private:
const VkDescriptorSetLayoutBinding *newBindings,
size_t newBindingsCount);
void FetchVSOut(uint32_t eventId);
void FetchTessGSOut(uint32_t eventId);
void FetchVSOut(uint32_t eventId, VulkanRenderState &state);
void FetchTessGSOut(uint32_t eventId, VulkanRenderState &state);
void ClearPostVSCache();
void RefreshDerivedReplacements();
renderdoc/driver/vulkan/vk_state.cpp
+61 -60
View File
@@ -23,17 +23,19 @@
******************************************************************************/
#include "vk_state.h"
#include "vk_common.h"
#include "vk_core.h"
#include "vk_debug.h"
#include "vk_info.h"
#include "vk_resources.h"
VulkanRenderState::VulkanRenderState(WrappedVulkan *driver, VulkanCreationInfo *createInfo)
: m_CreationInfo(createInfo), m_pDriver(driver)
VulkanRenderState::VulkanRenderState()
{
RDCEraseEl(ibuffer);
}
void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, PipelineBinding binding)
void VulkanRenderState::BeginRenderPassAndApplyState(WrappedVulkan *vk, VkCommandBuffer cmd,
PipelineBinding binding)
{
RDCASSERT(renderPass != ResourceId());
@@ -43,17 +45,18 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli
VkClearValue empty[16] = {};
RDCASSERT(ARRAY_COUNT(empty) >= m_CreationInfo->m_RenderPass[renderPass].attachments.size());
RDCASSERT(ARRAY_COUNT(empty) >=
vk->GetDebugManager()->GetRenderPassInfo(renderPass).attachments.size());
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo->m_Framebuffer[framebuffer];
VulkanCreationInfo::Framebuffer fbinfo = vk->GetDebugManager()->GetFramebufferInfo(framebuffer);
VkRenderPassBeginInfo rpbegin = {
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
NULL,
Unwrap(m_CreationInfo->m_RenderPass[renderPass].loadRPs[subpass]),
Unwrap(vk->GetDebugManager()->GetRenderPassInfo(renderPass).loadRPs[subpass]),
Unwrap(fbinfo.loadFBs[subpass]),
renderArea,
(uint32_t)m_CreationInfo->m_RenderPass[renderPass].attachments.size(),
(uint32_t)vk->GetDebugManager()->GetRenderPassInfo(renderPass).attachments.size(),
empty,
};
@@ -69,14 +72,14 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli
for(size_t i = 0; i < fbattachments.size(); i++)
imagelessViews.push_back(
Unwrap(GetResourceManager()->GetCurrentHandle<VkImageView>(fbattachments[i])));
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkImageView>(fbattachments[i])));
imagelessAttachments.pAttachments = imagelessViews.data();
}
ObjDisp(cmd)->CmdBeginRenderPass(Unwrap(cmd), &rpbegin, VK_SUBPASS_CONTENTS_INLINE);
BindPipeline(cmd, binding, true);
BindPipeline(vk, cmd, binding, true);
if(IsConditionalRenderingEnabled())
{
@@ -84,7 +87,7 @@ void VulkanRenderState::BeginRenderPassAndApplyState(VkCommandBuffer cmd, Pipeli
beginInfo.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
beginInfo.pNext = VK_NULL_HANDLE;
beginInfo.buffer =
Unwrap(GetResourceManager()->GetCurrentHandle<VkBuffer>(conditionalRendering.buffer));
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(conditionalRendering.buffer));
beginInfo.offset = conditionalRendering.offset;
beginInfo.flags = conditionalRendering.flags;
@@ -97,7 +100,7 @@ void VulkanRenderState::EndRenderPass(VkCommandBuffer cmd)
ObjDisp(cmd)->CmdEndRenderPass(Unwrap(cmd));
}
void VulkanRenderState::EndTransformFeedback(VkCommandBuffer cmd)
void VulkanRenderState::EndTransformFeedback(WrappedVulkan *vk, VkCommandBuffer cmd)
{
if(!xfbcounters.empty())
{
@@ -106,7 +109,8 @@ void VulkanRenderState::EndTransformFeedback(VkCommandBuffer cmd)
for(size_t i = 0; i < xfbcounters.size(); i++)
{
buffers.push_back(Unwrap(GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbcounters[i].buf)));
buffers.push_back(
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbcounters[i].buf)));
offsets.push_back(xfbcounters[i].offs);
}
@@ -126,29 +130,31 @@ bool VulkanRenderState::IsConditionalRenderingEnabled()
return conditionalRendering.buffer != ResourceId() && !conditionalRendering.forceDisable;
}
void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding binding, bool subpass0)
void VulkanRenderState::BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd,
PipelineBinding binding, bool subpass0)
{
if(graphics.pipeline != ResourceId() && binding == BindGraphics)
{
VkPipeline pipe = GetResourceManager()->GetCurrentHandle<VkPipeline>(graphics.pipeline);
VkPipeline pipe = vk->GetResourceManager()->GetCurrentHandle<VkPipeline>(graphics.pipeline);
const VulkanCreationInfo::Pipeline pipeinfo =
vk->GetDebugManager()->GetPipelineInfo(graphics.pipeline);
if(subpass0 && m_CreationInfo->m_Pipeline[graphics.pipeline].subpass0pipe != VK_NULL_HANDLE)
pipe = m_CreationInfo->m_Pipeline[graphics.pipeline].subpass0pipe;
if(subpass0 && pipeinfo.subpass0pipe != VK_NULL_HANDLE)
pipe = pipeinfo.subpass0pipe;
ObjDisp(cmd)->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(pipe));
ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[graphics.pipeline].layout;
VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayoutId);
ResourceId pipeLayoutId = pipeinfo.layout;
VkPipelineLayout layout =
vk->GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayoutId);
const rdcarray<VkPushConstantRange> &pushRanges =
m_CreationInfo->m_PipelineLayout[pipeLayoutId].pushRanges;
vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).pushRanges;
bool dynamicStates[VkDynamicCount] = {0};
memcpy(dynamicStates, m_CreationInfo->m_Pipeline[graphics.pipeline].dynamicStates,
sizeof(dynamicStates));
memcpy(dynamicStates, pipeinfo.dynamicStates, sizeof(dynamicStates));
RDCCOMPILE_ASSERT(sizeof(dynamicStates) ==
sizeof(m_CreationInfo->m_Pipeline[graphics.pipeline].dynamicStates),
RDCCOMPILE_ASSERT(sizeof(dynamicStates) == sizeof(pipeinfo.dynamicStates),
"Dynamic states array size is out of sync");
if(!views.empty() && dynamicStates[VkDynamicViewport])
@@ -209,7 +215,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
pushRanges[i].offset, pushRanges[i].size,
pushconsts + pushRanges[i].offset);
BindDescriptorSets(cmd, graphics, VK_PIPELINE_BIND_POINT_GRAPHICS);
BindDescriptorSets(vk, cmd, graphics, VK_PIPELINE_BIND_POINT_GRAPHICS);
if(ibuffer.buf != ResourceId())
{
@@ -220,7 +226,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
type = VK_INDEX_TYPE_UINT8_EXT;
ObjDisp(cmd)->CmdBindIndexBuffer(
Unwrap(cmd), Unwrap(GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
ibuffer.offs, type);
}
@@ -231,7 +237,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
ObjDisp(cmd)->CmdBindVertexBuffers(
Unwrap(cmd), (uint32_t)i, 1,
UnwrapPtr(GetResourceManager()->GetCurrentHandle<VkBuffer>(vbuffers[i].buf)),
UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(vbuffers[i].buf)),
&vbuffers[i].offs);
}
@@ -242,7 +248,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
ObjDisp(cmd)->CmdBindTransformFeedbackBuffersEXT(
Unwrap(cmd), (uint32_t)i, 1,
UnwrapPtr(GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbbuffers[i].buf)),
UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbbuffers[i].buf)),
&xfbbuffers[i].offs, &xfbbuffers[i].size);
}
@@ -254,7 +260,7 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
for(size_t i = 0; i < xfbcounters.size(); i++)
{
buffers.push_back(
Unwrap(GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbcounters[i].buf)));
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(xfbcounters[i].buf)));
offsets.push_back(xfbcounters[i].offs);
}
@@ -267,13 +273,14 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
{
ObjDisp(cmd)->CmdBindPipeline(
Unwrap(cmd), VK_PIPELINE_BIND_POINT_COMPUTE,
Unwrap(GetResourceManager()->GetCurrentHandle<VkPipeline>(compute.pipeline)));
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkPipeline>(compute.pipeline)));
ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[compute.pipeline].layout;
VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayoutId);
ResourceId pipeLayoutId = vk->GetDebugManager()->GetPipelineInfo(compute.pipeline).layout;
VkPipelineLayout layout =
vk->GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayoutId);
const rdcarray<VkPushConstantRange> &pushRanges =
m_CreationInfo->m_PipelineLayout[pipeLayoutId].pushRanges;
vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).pushRanges;
// only set push constant ranges that the layout uses
for(size_t i = 0; i < pushRanges.size(); i++)
@@ -281,20 +288,20 @@ void VulkanRenderState::BindPipeline(VkCommandBuffer cmd, PipelineBinding bindin
pushRanges[i].offset, pushRanges[i].size,
pushconsts + pushRanges[i].offset);
BindDescriptorSets(cmd, compute, VK_PIPELINE_BIND_POINT_COMPUTE);
BindDescriptorSets(vk, cmd, compute, VK_PIPELINE_BIND_POINT_COMPUTE);
}
}
void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipeline &pipe,
VkPipelineBindPoint bindPoint)
void VulkanRenderState::BindDescriptorSets(WrappedVulkan *vk, VkCommandBuffer cmd,
VulkanStatePipeline &pipe, VkPipelineBindPoint bindPoint)
{
ResourceId pipeLayoutId = m_CreationInfo->m_Pipeline[pipe.pipeline].layout;
ResourceId pipeLayoutId = vk->GetDebugManager()->GetPipelineInfo(pipe.pipeline).layout;
const rdcarray<ResourceId> &descSetLayouts =
m_CreationInfo->m_PipelineLayout[pipeLayoutId].descSetLayouts;
vk->GetDebugManager()->GetPipelineLayoutInfo(pipeLayoutId).descSetLayouts;
for(size_t i = 0; i < descSetLayouts.size(); i++)
{
const DescSetLayout &descLayout = m_CreationInfo->m_DescSetLayout[descSetLayouts[i]];
const DescSetLayout &descLayout = vk->GetDebugManager()->GetDescSetLayout(descSetLayouts[i]);
if(i < pipe.descSets.size() && pipe.descSets[i].descSet != ResourceId())
{
@@ -306,13 +313,12 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel
// by the next drawcall. The remaining sets are invalid, but also unused and this is
// explicitly allowed by the spec. We just have to make sure we don't try to actively bind
// an incompatible descriptor set.
ResourceId createdDescSetLayoutId =
m_pDriver->GetDescLayoutForDescSet(pipe.descSets[i].descSet);
ResourceId createdDescSetLayoutId = vk->GetDescLayoutForDescSet(pipe.descSets[i].descSet);
if(descSetLayouts[i] != createdDescSetLayoutId)
{
const DescSetLayout &createdDescLayout =
m_CreationInfo->m_DescSetLayout[createdDescSetLayoutId];
vk->GetDebugManager()->GetDescSetLayout(createdDescSetLayoutId);
if(descLayout != createdDescLayout)
{
@@ -348,7 +354,7 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel
}
}
BindDescriptorSet(descLayout, cmd, bindPoint, (uint32_t)i, dynamicOffsets);
BindDescriptorSet(vk, descLayout, cmd, bindPoint, (uint32_t)i, dynamicOffsets);
if(pipe.descSets[i].offsets.size() < descLayout.dynamicCount)
SAFE_DELETE_ARRAY(dynamicOffsets);
@@ -356,9 +362,9 @@ void VulkanRenderState::BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipel
}
}
void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCommandBuffer cmd,
VkPipelineBindPoint bindPoint, uint32_t setIndex,
uint32_t *dynamicOffsets)
void VulkanRenderState::BindDescriptorSet(WrappedVulkan *vk, const DescSetLayout &descLayout,
VkCommandBuffer cmd, VkPipelineBindPoint bindPoint,
uint32_t setIndex, uint32_t *dynamicOffsets)
{
ResourceId descSet = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? graphics.descSets[setIndex].descSet
@@ -366,13 +372,13 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
ResourceId pipeLayout = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? graphics.descSets[setIndex].pipeLayout
: compute.descSets[setIndex].pipeLayout;
VkPipelineLayout layout = GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayout);
VkPipelineLayout layout = vk->GetResourceManager()->GetCurrentHandle<VkPipelineLayout>(pipeLayout);
if((descLayout.flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) == 0)
{
ObjDisp(cmd)->CmdBindDescriptorSets(
Unwrap(cmd), bindPoint, Unwrap(layout), (uint32_t)setIndex, 1,
UnwrapPtr(GetResourceManager()->GetCurrentHandle<VkDescriptorSet>(descSet)),
UnwrapPtr(vk->GetResourceManager()->GetCurrentHandle<VkDescriptorSet>(descSet)),
descLayout.dynamicCount, dynamicOffsets);
}
else
@@ -386,7 +392,7 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
rdcarray<VkDescriptorBufferInfo *> allocBufWrites;
rdcarray<VkBufferView *> allocBufViewWrites;
WrappedVulkan::DescriptorSetInfo &setInfo = m_pDriver->m_DescriptorSetState[descSet];
const WrappedVulkan::DescriptorSetInfo &setInfo = vk->GetDebugManager()->GetDescSetInfo(descSet);
VkWriteDescriptorSet push = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
@@ -412,8 +418,8 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
VkBufferView *dst = new VkBufferView[push.descriptorCount];
for(uint32_t a = 0; a < push.descriptorCount; a++)
dst[a] =
Unwrap(GetResourceManager()->GetCurrentHandle<VkBufferView>(slots[a].texelBufferView));
dst[a] = Unwrap(
vk->GetResourceManager()->GetCurrentHandle<VkBufferView>(slots[a].texelBufferView));
push.pTexelBufferView = dst;
allocBufViewWrites.push_back(dst);
@@ -431,9 +437,9 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
const DescriptorSetSlotImageInfo &src = slots[a].imageInfo;
dst[a].imageLayout = src.imageLayout;
dst[a].sampler = Unwrap(GetResourceManager()->GetCurrentHandle<VkSampler>(src.sampler));
dst[a].sampler = Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkSampler>(src.sampler));
dst[a].imageView =
Unwrap(GetResourceManager()->GetCurrentHandle<VkImageView>(src.imageView));
Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkImageView>(src.imageView));
}
push.pImageInfo = dst;
@@ -449,7 +455,7 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
dst[a].offset = src.offset;
dst[a].range = src.range;
dst[a].buffer = Unwrap(GetResourceManager()->GetCurrentHandle<VkBuffer>(src.buffer));
dst[a].buffer = Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(src.buffer));
}
push.pBufferInfo = dst;
@@ -511,12 +517,12 @@ void VulkanRenderState::BindDescriptorSet(const DescSetLayout &descLayout, VkCom
}
}
void VulkanRenderState::SetFramebuffer(ResourceId fb,
void VulkanRenderState::SetFramebuffer(WrappedVulkan *vk, ResourceId fb,
const VkRenderPassAttachmentBeginInfo *attachmentsInfo)
{
framebuffer = fb;
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo->m_Framebuffer[fb];
VulkanCreationInfo::Framebuffer fbinfo = vk->GetDebugManager()->GetFramebufferInfo(fb);
fbattachments.resize(fbinfo.attachments.size());
@@ -531,8 +537,3 @@ void VulkanRenderState::SetFramebuffer(ResourceId fb,
fbattachments[i] = GetResID(attachmentsInfo->pAttachments[i]);
}
}
VulkanResourceManager *VulkanRenderState::GetResourceManager()
{
return m_pDriver->GetResourceManager();
}
renderdoc/driver/vulkan/vk_state.h
+14 -17
View File
@@ -53,23 +53,22 @@ struct VulkanRenderState
BindCompute = 0x2,
};
VulkanRenderState(WrappedVulkan *driver, VulkanCreationInfo *createInfo);
void BeginRenderPassAndApplyState(VkCommandBuffer cmd, PipelineBinding binding);
void EndRenderPass(VkCommandBuffer cmd);
VulkanRenderState();
bool IsConditionalRenderingEnabled();
void BeginRenderPassAndApplyState(WrappedVulkan *vk, VkCommandBuffer cmd, PipelineBinding binding);
void BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd, PipelineBinding binding, bool subpass0);
void EndTransformFeedback(VkCommandBuffer cmd);
void EndConditionalRendering(VkCommandBuffer cmd);
void BindPipeline(VkCommandBuffer cmd, PipelineBinding binding, bool subpass0);
void BindDescriptorSets(VkCommandBuffer cmd, VulkanStatePipeline &pipe,
void BindDescriptorSets(WrappedVulkan *vk, VkCommandBuffer cmd, VulkanStatePipeline &pipe,
VkPipelineBindPoint bindPoint);
void BindDescriptorSet(const DescSetLayout &descLayout, VkCommandBuffer cmd,
void BindDescriptorSet(WrappedVulkan *vk, const DescSetLayout &descLayout, VkCommandBuffer cmd,
VkPipelineBindPoint bindPoint, uint32_t setIndex, uint32_t *dynamicOffsets);
bool IsConditionalRenderingEnabled();
void EndRenderPass(VkCommandBuffer cmd);
void EndTransformFeedback(WrappedVulkan *vk, VkCommandBuffer cmd);
void EndConditionalRendering(VkCommandBuffer cmd);
// dynamic state
rdcarray<VkViewport> views;
@@ -113,7 +112,9 @@ struct VulkanRenderState
// framebuffer accessors - to allow for imageless framebuffers and prevent accidentally changing
// only the framebuffer without updating the attachments
void SetFramebuffer(ResourceId fb, const VkRenderPassAttachmentBeginInfo *attachmentsInfo = NULL);
void SetFramebuffer(WrappedVulkan *vk, ResourceId fb,
const VkRenderPassAttachmentBeginInfo *attachmentsInfo = NULL);
void SetFramebuffer(ResourceId fb, const rdcarray<ResourceId> &dynamicAttachments)
{
framebuffer = fb;
@@ -166,10 +167,6 @@ struct VulkanRenderState
bool forceDisable = false;
} conditionalRendering;
VulkanResourceManager *GetResourceManager();
VulkanCreationInfo *m_CreationInfo;
WrappedVulkan *m_pDriver;
private:
ResourceId framebuffer;
rdcarray<ResourceId> fbattachments;
renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp
+216 -230
View File
@@ -58,7 +58,7 @@ void WrappedVulkan::AddImplicitResolveResourceUsage(uint32_t subpass)
subpass = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass;
const rdcarray<ResourceId> &fbattachments =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments();
for(size_t i = 0; i < rpinfo.subpasses[subpass].resolveAttachments.size(); i++)
{
uint32_t attIdx = rpinfo.subpasses[subpass].resolveAttachments[i];
@@ -84,9 +84,10 @@ rdcarray<VkImageMemoryBarrier> WrappedVulkan::GetImplicitRenderPassBarriers(uint
}
else
{
rp = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass;
fb = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer;
fbattachments = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments;
const VulkanRenderState &renderstate = GetCmdRenderState();
rp = renderstate.renderPass;
fb = renderstate.GetFramebuffer();
fbattachments = renderstate.GetFramebufferAttachments();
}
rdcarray<VkImageMemoryBarrier> ret;
@@ -121,7 +122,7 @@ rdcarray<VkImageMemoryBarrier> WrappedVulkan::GetImplicitRenderPassBarriers(uint
if(m_LastCmdBufferID == ResourceId())
subpass = m_RenderState.subpass;
else
subpass = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass;
subpass = GetCmdRenderState().subpass;
// transition the attachments in this subpass
for(size_t i = 0; i < rpinfo.subpasses[subpass].colorAttachments.size(); i++)
@@ -306,7 +307,7 @@ rdcstr WrappedVulkan::MakeRenderPassOpString(bool store)
const VulkanCreationInfo::RenderPass &info =
m_CreationInfo.m_RenderPass[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass];
const VulkanCreationInfo::Framebuffer &fbinfo =
m_CreationInfo.m_Framebuffer[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer];
m_CreationInfo.m_Framebuffer[m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebuffer()];
const rdcarray<VulkanCreationInfo::RenderPass::Attachment> &atts = info.attachments;
@@ -788,8 +789,9 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman
m_Partial[p].partialParent = BakedCommandBuffer;
m_Partial[p].baseEvent = it->baseEvent;
m_Partial[p].renderPassActive = false;
m_RenderState.xfbcounters.clear();
m_RenderState.conditionalRendering.buffer = ResourceId();
GetCmdRenderState().xfbcounters.clear();
GetCmdRenderState().conditionalRendering.buffer = ResourceId();
rerecord = true;
partial = true;
@@ -1042,16 +1044,16 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB
ToStr(GetResID(commandBuffer)).c_str());
#endif
if(m_Partial[Primary].partialParent == BakedCommandBuffer &&
!m_RenderState.xfbcounters.empty())
VulkanRenderState &renderstate = GetCmdRenderState();
if(m_Partial[Primary].partialParent == BakedCommandBuffer && !renderstate.xfbcounters.empty())
{
m_RenderState.EndTransformFeedback(commandBuffer);
renderstate.EndTransformFeedback(this, commandBuffer);
}
if(m_Partial[Primary].partialParent == BakedCommandBuffer &&
m_RenderState.IsConditionalRenderingEnabled())
renderstate.IsConditionalRenderingEnabled())
{
m_RenderState.EndConditionalRendering(commandBuffer);
renderstate.EndConditionalRendering(commandBuffer);
}
// finish any render pass that was still active in the primary partial parent
@@ -1059,18 +1061,16 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB
m_Partial[Primary].renderPassActive)
{
uint32_t numSubpasses =
(uint32_t)m_CreationInfo.m_RenderPass[m_RenderState.renderPass].subpasses.size();
(uint32_t)m_CreationInfo.m_RenderPass[renderstate.renderPass].subpasses.size();
// for each subpass we skip, and for the finalLayout transition at the end of the
// renderpass, record these barriers. These are executed implicitly but because we want to
// pretend they never happened, we then reverse their effects so that our layout tracking
// is accurate and the images end up in the layout they were in during the last active
// subpass
uint32_t &sub = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass;
std::map<ResourceId, ImageState> renderPassEndStates;
for(sub = m_RenderState.subpass + 1; sub < numSubpasses; sub++)
for(uint32_t sub = renderstate.subpass + 1; sub < numSubpasses; sub++)
{
ObjDisp(commandBuffer)->CmdNextSubpass(Unwrap(commandBuffer), VK_SUBPASS_CONTENTS_INLINE);
@@ -1127,8 +1127,10 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(SerialiserType &ser, VkCommandB
ObjDisp(commandBuffer)->EndCommandBuffer(Unwrap(commandBuffer));
if(m_Partial[Primary].partialParent == BakedCommandBuffer)
m_Partial[Primary].partialParent = ResourceId();
// TODO: preserve so that m_RenderState can be updated at the end
// of replay.
// if(m_Partial[Primary].partialParent == BakedCommandBuffer)
// m_Partial[Primary].partialParent = ResourceId();
}
m_BakedCmdBufferInfo[CommandBuffer].curEventID = 0;
@@ -1262,49 +1264,40 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass = 0;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass =
GetResID(RenderPassBegin.renderPass);
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb;
const VkRenderPassAttachmentBeginInfo *attachmentsInfo =
(const VkRenderPassAttachmentBeginInfo *)FindNextStruct(
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(
fbinfo.attachments.size());
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
fbinfo.attachments[i].createdView;
}
else
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
GetResID(attachmentsInfo->pAttachments[i]);
}
}
// only if we're partially recording do we update this state
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
{
m_Partial[Primary].renderPassActive = true;
}
m_RenderState.subpass = 0;
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
m_RenderState.renderPass = GetResID(RenderPassBegin.renderPass);
m_RenderState.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachmentsInfo);
m_RenderState.renderArea = RenderPassBegin.renderArea;
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.subpass = 0;
renderstate.renderPass = GetResID(RenderPassBegin.renderPass);
renderstate.renderArea = RenderPassBegin.renderArea;
const VkRenderPassAttachmentBeginInfo *attachmentsInfo =
(const VkRenderPassAttachmentBeginInfo *)FindNextStruct(
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
rdcarray<ResourceId> attachments(fbinfo.attachments.size());
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
attachments[i] = fbinfo.attachments[i].createdView;
}
else
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
attachments[i] = GetResID(attachmentsInfo->pAttachments[i]);
}
renderstate.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachments);
}
rdcarray<VkImageMemoryBarrier> imgBarriers = GetImplicitRenderPassBarriers();
@@ -1316,9 +1309,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman
// be in subpass 0's layout
if(m_FirstEventID == m_LastEventID)
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
VulkanCreationInfo::RenderPass rpinfo =
m_CreationInfo.m_RenderPass[m_RenderState.renderPass];
m_CreationInfo.m_RenderPass[GetCmdRenderState().renderPass];
unwrappedInfo.renderPass = Unwrap(rpinfo.loadRPs[0]);
unwrappedInfo.framebuffer = Unwrap(fbinfo.loadFBs[0]);
@@ -1354,19 +1346,17 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = GetResID(RenderPassBegin.renderPass);
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb;
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(fbinfo.attachments.size());
rdcarray<ResourceId> attachments(fbinfo.attachments.size());
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
fbinfo.attachments[i].createdView;
attachments[i] = fbinfo.attachments[i].createdView;
}
else
{
@@ -1375,16 +1365,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
GetResID(attachmentsInfo->pAttachments[i]);
attachments[i] = GetResID(attachmentsInfo->pAttachments[i]);
}
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(fb, attachments);
}
// Record image usage for images cleared in the beginning of the render pass.
const VulkanCreationInfo::RenderPass &rpinfo =
m_CreationInfo.m_RenderPass[GetResID(RenderPassBegin.renderPass)];
const rdcarray<ResourceId> &fbattachments =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments();
for(size_t i = 0; i < rpinfo.attachments.size(); i++)
{
if(rpinfo.attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
@@ -1520,11 +1510,9 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass(SerialiserType &ser, VkCommandBuf
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass++;
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
m_RenderState.subpass++;
{
GetCmdRenderState().subpass++;
}
DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::BeginPass | DrawFlags::EndPass;
uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags);
@@ -1614,16 +1602,17 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB
rdcarray<VkImageMemoryBarrier> imgBarriers = GetImplicitRenderPassBarriers(~0U);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.clear();
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
{
m_Partial[Primary].renderPassActive = false;
}
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.renderPass = ResourceId();
renderstate.SetFramebuffer(ResourceId(), rdcarray<ResourceId>());
}
DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::EndPass;
uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags);
@@ -1671,8 +1660,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB
// track while reading, reset this to empty so AddDrawcall sets no outputs,
// but only AFTER the above AddDrawcall (we want it grouped together)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.clear();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(ResourceId(),
rdcarray<ResourceId>());
}
}
@@ -1740,49 +1729,39 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass = 0;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass =
GetResID(RenderPassBegin.renderPass);
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb;
const VkRenderPassAttachmentBeginInfo *attachmentsInfo =
(const VkRenderPassAttachmentBeginInfo *)FindNextStruct(
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(
fbinfo.attachments.size());
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
fbinfo.attachments[i].createdView;
}
else
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
GetResID(attachmentsInfo->pAttachments[i]);
}
}
// only if we're partially recording do we update this state
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
{
m_Partial[Primary].renderPassActive = true;
}
m_RenderState.subpass = 0;
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.subpass = 0;
renderstate.renderPass = GetResID(RenderPassBegin.renderPass);
renderstate.renderArea = RenderPassBegin.renderArea;
m_RenderState.renderPass = GetResID(RenderPassBegin.renderPass);
m_RenderState.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachmentsInfo);
m_RenderState.renderArea = RenderPassBegin.renderArea;
const VkRenderPassAttachmentBeginInfo *attachmentsInfo =
(const VkRenderPassAttachmentBeginInfo *)FindNextStruct(
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
rdcarray<ResourceId> attachments(fbinfo.attachments.size());
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
attachments[i] = fbinfo.attachments[i].createdView;
}
else
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
attachments[i] = GetResID(attachmentsInfo->pAttachments[i]);
}
renderstate.SetFramebuffer(GetResID(RenderPassBegin.framebuffer), attachments);
}
rdcarray<VkImageMemoryBarrier> imgBarriers = GetImplicitRenderPassBarriers();
@@ -1794,9 +1773,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser,
// be in subpass 0's layout
if(m_FirstEventID == m_LastEventID)
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
// VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
VulkanCreationInfo::RenderPass rpinfo =
m_CreationInfo.m_RenderPass[m_RenderState.renderPass];
m_CreationInfo.m_RenderPass[GetCmdRenderState().renderPass];
unwrappedInfo.renderPass = Unwrap(rpinfo.loadRPs[0]);
unwrappedInfo.framebuffer = Unwrap(fbinfo.loadFBs[0]);
@@ -1834,19 +1813,17 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser,
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = GetResID(RenderPassBegin.renderPass);
ResourceId fb = GetResID(RenderPassBegin.framebuffer);
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = fb;
// set framebuffer attachments - by default from the ones used to create it, but if it is
// imageless then look for the attachments in our pNext chain
{
VulkanCreationInfo::Framebuffer fbinfo = m_CreationInfo.m_Framebuffer[fb];
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments.resize(fbinfo.attachments.size());
rdcarray<ResourceId> attachments(fbinfo.attachments.size());
if(!fbinfo.imageless)
{
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
fbinfo.attachments[i].createdView;
attachments[i] = fbinfo.attachments[i].createdView;
}
else
{
@@ -1855,16 +1832,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser,
&RenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
for(size_t i = 0; i < fbinfo.attachments.size(); i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments[i] =
GetResID(attachmentsInfo->pAttachments[i]);
attachments[i] = GetResID(attachmentsInfo->pAttachments[i]);
}
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(fb, attachments);
}
// Record image usage for images cleared in the beginning of the render pass.
const VulkanCreationInfo::RenderPass &rpinfo =
m_CreationInfo.m_RenderPass[GetResID(RenderPassBegin.renderPass)];
const rdcarray<ResourceId> &fbattachments =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.fbattachments;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments();
for(size_t i = 0; i < rpinfo.attachments.size(); i++)
{
if(rpinfo.attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
@@ -2016,11 +1993,9 @@ bool WrappedVulkan::Serialise_vkCmdNextSubpass2(SerialiserType &ser, VkCommandBu
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.subpass++;
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
m_RenderState.subpass++;
{
GetCmdRenderState().subpass++;
}
DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::BeginPass | DrawFlags::EndPass;
uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags);
@@ -2133,15 +2108,17 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand
rdcarray<VkImageMemoryBarrier> imgBarriers = GetImplicitRenderPassBarriers(~0U);
// always track this, for WrappedVulkan::IsDrawInRenderPass()
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId();
if(ShouldUpdateRenderState(m_LastCmdBufferID, true))
{
m_Partial[Primary].renderPassActive = false;
}
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.renderPass = ResourceId();
renderstate.SetFramebuffer(ResourceId(), rdcarray<ResourceId>());
}
DrawFlags drawFlags = DrawFlags::PassBoundary | DrawFlags::EndPass;
uint32_t eventId = HandlePreCallback(commandBuffer, drawFlags);
ObjDisp(commandBuffer)->CmdEndRenderPass2(Unwrap(commandBuffer), &unwrappedEndInfo);
@@ -2179,7 +2156,8 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand
// track while reading, reset this to empty so AddDrawcall sets no outputs,
// but only AFTER the above AddDrawcall (we want it grouped together)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.renderPass = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.framebuffer = ResourceId();
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.SetFramebuffer(ResourceId(),
rdcarray<ResourceId>());
}
}
@@ -2244,76 +2222,76 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu
ResourceId liveid = GetResID(pipeline);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
if(pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE)
{
m_RenderState.compute.pipeline = liveid;
renderstate.compute.pipeline = liveid;
}
else
{
m_RenderState.graphics.pipeline = liveid;
renderstate.graphics.pipeline = liveid;
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicViewport])
{
m_RenderState.views = m_CreationInfo.m_Pipeline[liveid].viewports;
renderstate.views = m_CreationInfo.m_Pipeline[liveid].viewports;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicScissor])
{
m_RenderState.scissors = m_CreationInfo.m_Pipeline[liveid].scissors;
renderstate.scissors = m_CreationInfo.m_Pipeline[liveid].scissors;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicLineWidth])
{
m_RenderState.lineWidth = m_CreationInfo.m_Pipeline[liveid].lineWidth;
renderstate.lineWidth = m_CreationInfo.m_Pipeline[liveid].lineWidth;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDepthBias])
{
m_RenderState.bias.depth = m_CreationInfo.m_Pipeline[liveid].depthBiasConstantFactor;
m_RenderState.bias.biasclamp = m_CreationInfo.m_Pipeline[liveid].depthBiasClamp;
m_RenderState.bias.slope = m_CreationInfo.m_Pipeline[liveid].depthBiasSlopeFactor;
renderstate.bias.depth = m_CreationInfo.m_Pipeline[liveid].depthBiasConstantFactor;
renderstate.bias.biasclamp = m_CreationInfo.m_Pipeline[liveid].depthBiasClamp;
renderstate.bias.slope = m_CreationInfo.m_Pipeline[liveid].depthBiasSlopeFactor;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicBlendConstants])
{
memcpy(m_RenderState.blendConst, m_CreationInfo.m_Pipeline[liveid].blendConst,
memcpy(renderstate.blendConst, m_CreationInfo.m_Pipeline[liveid].blendConst,
sizeof(float) * 4);
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDepthBounds])
{
m_RenderState.mindepth = m_CreationInfo.m_Pipeline[liveid].minDepthBounds;
m_RenderState.maxdepth = m_CreationInfo.m_Pipeline[liveid].maxDepthBounds;
renderstate.mindepth = m_CreationInfo.m_Pipeline[liveid].minDepthBounds;
renderstate.maxdepth = m_CreationInfo.m_Pipeline[liveid].maxDepthBounds;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilCompareMask])
{
m_RenderState.front.compare = m_CreationInfo.m_Pipeline[liveid].front.compareMask;
m_RenderState.back.compare = m_CreationInfo.m_Pipeline[liveid].back.compareMask;
renderstate.front.compare = m_CreationInfo.m_Pipeline[liveid].front.compareMask;
renderstate.back.compare = m_CreationInfo.m_Pipeline[liveid].back.compareMask;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilWriteMask])
{
m_RenderState.front.write = m_CreationInfo.m_Pipeline[liveid].front.writeMask;
m_RenderState.back.write = m_CreationInfo.m_Pipeline[liveid].back.writeMask;
renderstate.front.write = m_CreationInfo.m_Pipeline[liveid].front.writeMask;
renderstate.back.write = m_CreationInfo.m_Pipeline[liveid].back.writeMask;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicStencilReference])
{
m_RenderState.front.ref = m_CreationInfo.m_Pipeline[liveid].front.reference;
m_RenderState.back.ref = m_CreationInfo.m_Pipeline[liveid].back.reference;
renderstate.front.ref = m_CreationInfo.m_Pipeline[liveid].front.reference;
renderstate.back.ref = m_CreationInfo.m_Pipeline[liveid].back.reference;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicSampleLocationsEXT])
{
m_RenderState.sampleLocations.locations =
renderstate.sampleLocations.locations =
m_CreationInfo.m_Pipeline[liveid].sampleLocations.locations;
m_RenderState.sampleLocations.gridSize =
renderstate.sampleLocations.gridSize =
m_CreationInfo.m_Pipeline[liveid].sampleLocations.gridSize;
m_RenderState.sampleLocations.sampleCount =
renderstate.sampleLocations.sampleCount =
m_CreationInfo.m_Pipeline[liveid].rasterizationSamples;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicDiscardRectangleEXT])
{
m_RenderState.discardRectangles = m_CreationInfo.m_Pipeline[liveid].discardRectangles;
renderstate.discardRectangles = m_CreationInfo.m_Pipeline[liveid].discardRectangles;
}
if(!m_CreationInfo.m_Pipeline[liveid].dynamicStates[VkDynamicLineStippleEXT])
{
m_RenderState.stippleFactor = m_CreationInfo.m_Pipeline[liveid].stippleFactor;
m_RenderState.stipplePattern = m_CreationInfo.m_Pipeline[liveid].stipplePattern;
renderstate.stippleFactor = m_CreationInfo.m_Pipeline[liveid].stippleFactor;
renderstate.stipplePattern = m_CreationInfo.m_Pipeline[liveid].stipplePattern;
}
}
}
@@ -2326,7 +2304,14 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu
else
{
// track while reading, as we need to bind current topology & index byte width in AddDrawcall
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.pipeline = GetResID(pipeline);
if(pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE)
{
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.pipeline = GetResID(pipeline);
}
else
{
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.pipeline = GetResID(pipeline);
}
}
if(commandBuffer != VK_NULL_HANDLE)
@@ -2394,12 +2379,12 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets(
firstSet, setCount, UnwrapArray(pDescriptorSets, setCount),
dynamicOffsetCount, pDynamicOffsets);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? m_RenderState.graphics.descSets
: m_RenderState.compute.descSets;
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets
: renderstate.compute.descSets;
// expand as necessary
if(descsets.size() < firstSet + setCount)
@@ -2466,10 +2451,10 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets(
else
{
// track while reading, as we need to track resource usage
rdcarray<BakedCmdBufferInfo::CmdBufferState::DescriptorAndOffsets> &descsets =
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets;
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets;
// expand as necessary
if(descsets.size() < firstSet + setCount)
@@ -2549,15 +2534,15 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser,
->CmdBindVertexBuffers(Unwrap(commandBuffer), firstBinding, bindingCount,
UnwrapArray(pBuffers, bindingCount), pOffsets);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
if(m_RenderState.vbuffers.size() < firstBinding + bindingCount)
m_RenderState.vbuffers.resize(firstBinding + bindingCount);
VulkanRenderState &renderstate = GetCmdRenderState();
if(renderstate.vbuffers.size() < firstBinding + bindingCount)
renderstate.vbuffers.resize(firstBinding + bindingCount);
for(uint32_t i = 0; i < bindingCount; i++)
{
m_RenderState.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]);
m_RenderState.vbuffers[firstBinding + i].offs = pOffsets[i];
renderstate.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]);
renderstate.vbuffers[firstBinding + i].offs = pOffsets[i];
}
}
}
@@ -2569,7 +2554,7 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser,
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers.resize(firstBinding + bindingCount);
for(uint32_t i = 0; i < bindingCount; i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers[firstBinding + i] =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers[firstBinding + i].buf =
GetResID(pBuffers[i]);
ObjDisp(commandBuffer)
@@ -2636,17 +2621,17 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser,
ObjDisp(commandBuffer)
->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offset, indexType);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.ibuffer.buf = GetResID(buffer);
m_RenderState.ibuffer.offs = offset;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.ibuffer.buf = GetResID(buffer);
renderstate.ibuffer.offs = offset;
if(indexType == VK_INDEX_TYPE_UINT32)
m_RenderState.ibuffer.bytewidth = 4;
renderstate.ibuffer.bytewidth = 4;
else if(indexType == VK_INDEX_TYPE_UINT8_EXT)
m_RenderState.ibuffer.bytewidth = 1;
renderstate.ibuffer.bytewidth = 1;
else
m_RenderState.ibuffer.bytewidth = 2;
renderstate.ibuffer.bytewidth = 2;
}
}
}
@@ -2654,14 +2639,14 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser,
{
// track while reading, as we need to bind current topology & index byte width in AddDrawcall
if(indexType == VK_INDEX_TYPE_UINT32)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 4;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 4;
else if(indexType == VK_INDEX_TYPE_UINT8_EXT)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 1;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 1;
else
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = 2;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 2;
// track while reading, as we need to track resource usage
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer = GetResID(buffer);
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.buf = GetResID(buffer);
ObjDisp(commandBuffer)->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offset, indexType);
}
@@ -2789,13 +2774,13 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants(SerialiserType &ser, VkCommandB
->CmdPushConstants(Unwrap(commandBuffer), Unwrap(layout), stageFlags, start, length,
values);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
RDCASSERT(start + length < (uint32_t)ARRAY_COUNT(m_RenderState.pushconsts));
VulkanRenderState &renderstate = GetCmdRenderState();
RDCASSERT(start + length < (uint32_t)ARRAY_COUNT(renderstate.pushconsts));
memcpy(m_RenderState.pushconsts + start, values, length);
memcpy(renderstate.pushconsts + start, values, length);
m_RenderState.pushConstSize = RDCMAX(m_RenderState.pushConstSize, start + length);
renderstate.pushConstSize = RDCMAX(renderstate.pushConstSize, start + length);
}
}
}
@@ -3375,7 +3360,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
// should we add framebuffer usage to the child draws.
bool framebufferUsage = parentCmdBufInfo.state.renderPass != ResourceId() &&
parentCmdBufInfo.state.framebuffer != ResourceId();
parentCmdBufInfo.state.GetFramebuffer() != ResourceId();
for(uint32_t c = 0; c < commandBufferCount; c++)
{
@@ -3419,8 +3404,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
{
AddFramebufferUsageAllChildren(
parentCmdBufInfo.draw->children[total - numChildren + i],
parentCmdBufInfo.state.renderPass, parentCmdBufInfo.state.framebuffer,
parentCmdBufInfo.state.subpass, parentCmdBufInfo.state.fbattachments);
parentCmdBufInfo.state.renderPass, parentCmdBufInfo.state.GetFramebuffer(),
parentCmdBufInfo.state.subpass, parentCmdBufInfo.state.GetFramebufferAttachments());
}
}
@@ -3500,8 +3485,9 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman
// propagate renderpass state
m_BakedCmdBufferInfo[cmd].state.renderPass = parentCmdBufInfo.state.renderPass;
m_BakedCmdBufferInfo[cmd].state.subpass = parentCmdBufInfo.state.subpass;
m_BakedCmdBufferInfo[cmd].state.framebuffer = parentCmdBufInfo.state.framebuffer;
m_BakedCmdBufferInfo[cmd].state.fbattachments = parentCmdBufInfo.state.fbattachments;
m_BakedCmdBufferInfo[cmd].state.SetFramebuffer(
parentCmdBufInfo.state.GetFramebuffer(),
parentCmdBufInfo.state.GetFramebufferAttachments());
// 2 extra for the virtual labels around the command buffer
parentCmdBufInfo.curEventID += 2 + m_BakedCmdBufferInfo[cmd].eventCount;
@@ -3988,12 +3974,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? m_RenderState.graphics.descSets
: m_RenderState.compute.descSets;
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets
: renderstate.compute.descSets;
// expand as necessary
if(descsets.size() < set + 1)
@@ -4013,10 +3998,10 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser,
else
{
// track while reading, as we need to track resource usage
rdcarray<BakedCmdBufferInfo::CmdBufferState::DescriptorAndOffsets> &descsets =
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets;
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets;
// expand as necessary
if(descsets.size() < set + 1)
@@ -4257,11 +4242,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR(
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? m_RenderState.graphics.descSets
: m_RenderState.compute.descSets;
(bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS) ? renderstate.graphics.descSets
: renderstate.compute.descSets;
// expand as necessary
if(descsets.size() < set + 1)
@@ -4281,11 +4266,11 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR(
else
{
// track while reading, as we need to track resource usage
rdcarray<BakedCmdBufferInfo::CmdBufferState::DescriptorAndOffsets> &descsets =
rdcarray<VulkanStatePipeline::DescriptorAndOffsets> &descsets =
(m_CreationInfo.m_DescUpdateTemplate[GetResID(descriptorUpdateTemplate)].bindPoint ==
VK_PIPELINE_BIND_POINT_GRAPHICS)
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets;
? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphics.descSets
: m_BakedCmdBufferInfo[m_LastCmdBufferID].state.compute.descSets;
// expand as necessary
if(descsets.size() < set + 1)
@@ -4823,16 +4808,16 @@ bool WrappedVulkan::Serialise_vkCmdBindTransformFeedbackBuffersEXT(
UnwrapArray(pBuffers, bindingCount), pOffsets,
pSizes);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
if(m_RenderState.xfbbuffers.size() < firstBinding + bindingCount)
m_RenderState.xfbbuffers.resize(firstBinding + bindingCount);
VulkanRenderState &renderstate = GetCmdRenderState();
if(renderstate.xfbbuffers.size() < firstBinding + bindingCount)
renderstate.xfbbuffers.resize(firstBinding + bindingCount);
for(uint32_t i = 0; i < bindingCount; i++)
{
m_RenderState.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]);
m_RenderState.xfbbuffers[firstBinding + i].offs = pOffsets[i];
m_RenderState.xfbbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE;
renderstate.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]);
renderstate.xfbbuffers[firstBinding + i].offs = pOffsets[i];
renderstate.xfbbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE;
}
}
}
@@ -4844,7 +4829,7 @@ bool WrappedVulkan::Serialise_vkCmdBindTransformFeedbackBuffersEXT(
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers.resize(firstBinding + bindingCount);
for(uint32_t i = 0; i < bindingCount; i++)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers[firstBinding + i] =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbbuffers[firstBinding + i].buf =
GetResID(pBuffers[i]);
ObjDisp(commandBuffer)
@@ -4918,17 +4903,16 @@ bool WrappedVulkan::Serialise_vkCmdBeginTransformFeedbackEXT(
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// only if we're partially recording do we update this state
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.firstxfbcounter = firstBuffer;
m_RenderState.xfbcounters.resize(bufferCount);
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.firstxfbcounter = firstBuffer;
renderstate.xfbcounters.resize(bufferCount);
for(uint32_t i = 0; i < bufferCount; i++)
{
m_RenderState.xfbcounters[i].buf =
renderstate.xfbcounters[i].buf =
pCounterBuffers ? GetResID(pCounterBuffers[i]) : ResourceId();
m_RenderState.xfbcounters[i].offs = pCounterBufferOffsets ? pCounterBufferOffsets[i] : 0;
renderstate.xfbcounters[i].offs = pCounterBufferOffsets ? pCounterBufferOffsets[i] : 0;
}
}
@@ -4946,8 +4930,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginTransformFeedbackEXT(
pCounterBufferOffsets);
// track while reading, for fetching the right set of outputs in AddDrawcall
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbfirst = firstBuffer;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcount = bufferCount;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.firstxfbcounter = firstBuffer;
// TODO: should change the xfbcount, resize?
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcounters.resize(bufferCount);
}
}
@@ -5014,11 +4999,10 @@ bool WrappedVulkan::Serialise_vkCmdEndTransformFeedbackEXT(
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
// only if we're partially recording do we update this state
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.firstxfbcounter = 0;
m_RenderState.xfbcounters.clear();
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.firstxfbcounter = 0;
renderstate.xfbcounters.clear();
}
ObjDisp(commandBuffer)
@@ -5035,8 +5019,8 @@ bool WrappedVulkan::Serialise_vkCmdEndTransformFeedbackEXT(
pCounterBufferOffsets);
// track while reading, for fetching the right set of outputs in AddDrawcall
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbfirst = 0;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcount = 0;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.firstxfbcounter = 0;
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.xfbcounters.clear();
}
}
@@ -5219,11 +5203,11 @@ bool WrappedVulkan::Serialise_vkCmdBeginConditionalRenderingEXT(
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.conditionalRendering.buffer = GetResID(BeginInfo.buffer);
m_RenderState.conditionalRendering.offset = BeginInfo.offset;
m_RenderState.conditionalRendering.flags = BeginInfo.flags;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.conditionalRendering.buffer = GetResID(BeginInfo.buffer);
renderstate.conditionalRendering.offset = BeginInfo.offset;
renderstate.conditionalRendering.flags = BeginInfo.flags;
}
BeginInfo.buffer = Unwrap(BeginInfo.buffer);
@@ -5291,8 +5275,10 @@ bool WrappedVulkan::Serialise_vkCmdEndConditionalRenderingEXT(SerialiserType &se
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
m_RenderState.conditionalRendering.buffer = ResourceId();
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.conditionalRendering.buffer = ResourceId();
}
ObjDisp(commandBuffer)->CmdEndConditionalRenderingEXT(Unwrap(commandBuffer));
}
renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp
+10 -11
View File
@@ -2421,10 +2421,9 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser,
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
const BakedCmdBufferInfo::CmdBufferState &state =
m_BakedCmdBufferInfo[m_LastCmdBufferID].state;
const VulkanRenderState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state;
if(state.renderPass != ResourceId() && state.framebuffer != ResourceId())
if(state.renderPass != ResourceId() && state.GetFramebuffer() != ResourceId())
{
VulkanCreationInfo::RenderPass &rp = m_CreationInfo.m_RenderPass[state.renderPass];
@@ -2439,10 +2438,10 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser,
if(att < (uint32_t)rp.subpasses[state.subpass].colorAttachments.size())
{
att = rp.subpasses[state.subpass].colorAttachments[att];
drawNode.resourceUsage.push_back(
make_rdcpair(m_CreationInfo.m_ImageView[state.fbattachments[att]].image,
EventUsage(drawNode.draw.eventId, ResourceUsage::Clear,
state.fbattachments[att])));
drawNode.resourceUsage.push_back(make_rdcpair(
m_CreationInfo.m_ImageView[state.GetFramebufferAttachments()[att]].image,
EventUsage(drawNode.draw.eventId, ResourceUsage::Clear,
state.GetFramebufferAttachments()[att])));
}
}
else if(pAttachments[a].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)
@@ -2450,10 +2449,10 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(SerialiserType &ser,
if(rp.subpasses[state.subpass].depthstencilAttachment >= 0)
{
att = (uint32_t)rp.subpasses[state.subpass].depthstencilAttachment;
drawNode.resourceUsage.push_back(
make_rdcpair(m_CreationInfo.m_ImageView[state.fbattachments[att]].image,
EventUsage(drawNode.draw.eventId, ResourceUsage::Clear,
state.fbattachments[att])));
drawNode.resourceUsage.push_back(make_rdcpair(
m_CreationInfo.m_ImageView[state.GetFramebufferAttachments()[att]].image,
EventUsage(drawNode.draw.eventId, ResourceUsage::Clear,
state.GetFramebufferAttachments()[att])));
}
}
}
renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp
+43 -40
View File
@@ -48,13 +48,13 @@ bool WrappedVulkan::Serialise_vkCmdSetViewport(SerialiserType &ser, VkCommandBuf
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
if(m_RenderState.views.size() < firstViewport + viewportCount)
m_RenderState.views.resize(firstViewport + viewportCount);
VulkanRenderState &renderstate = GetCmdRenderState();
if(renderstate.views.size() < firstViewport + viewportCount)
renderstate.views.resize(firstViewport + viewportCount);
for(uint32_t i = 0; i < viewportCount; i++)
m_RenderState.views[firstViewport + i] = pViewports[i];
renderstate.views[firstViewport + i] = pViewports[i];
}
}
else
@@ -117,13 +117,13 @@ bool WrappedVulkan::Serialise_vkCmdSetScissor(SerialiserType &ser, VkCommandBuff
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
if(m_RenderState.scissors.size() < firstScissor + scissorCount)
m_RenderState.scissors.resize(firstScissor + scissorCount);
VulkanRenderState &renderstate = GetCmdRenderState();
if(renderstate.scissors.size() < firstScissor + scissorCount)
renderstate.scissors.resize(firstScissor + scissorCount);
for(uint32_t i = 0; i < scissorCount; i++)
m_RenderState.scissors[firstScissor + i] = pScissors[i];
renderstate.scissors[firstScissor + i] = pScissors[i];
}
}
else
@@ -182,8 +182,9 @@ bool WrappedVulkan::Serialise_vkCmdSetLineWidth(SerialiserType &ser, VkCommandBu
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
m_RenderState.lineWidth = lineWidth;
{
GetCmdRenderState().lineWidth = lineWidth;
}
}
else
{
@@ -241,11 +242,11 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBias(SerialiserType &ser, VkCommandBu
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.bias.depth = depthBias;
m_RenderState.bias.biasclamp = depthBiasClamp;
m_RenderState.bias.slope = slopeScaledDepthBias;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.bias.depth = depthBias;
renderstate.bias.biasclamp = depthBiasClamp;
renderstate.bias.slope = slopeScaledDepthBias;
}
}
else
@@ -306,8 +307,10 @@ bool WrappedVulkan::Serialise_vkCmdSetBlendConstants(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
memcpy(m_RenderState.blendConst, blendConst, sizeof(m_RenderState.blendConst));
{
VulkanRenderState &renderstate = GetCmdRenderState();
memcpy(renderstate.blendConst, blendConst, sizeof(renderstate.blendConst));
}
}
else
{
@@ -363,10 +366,10 @@ bool WrappedVulkan::Serialise_vkCmdSetDepthBounds(SerialiserType &ser, VkCommand
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.mindepth = minDepthBounds;
m_RenderState.maxdepth = maxDepthBounds;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.mindepth = minDepthBounds;
renderstate.maxdepth = maxDepthBounds;
}
}
else
@@ -427,12 +430,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilCompareMask(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
if(faceMask & VK_STENCIL_FACE_FRONT_BIT)
m_RenderState.front.compare = compareMask;
renderstate.front.compare = compareMask;
if(faceMask & VK_STENCIL_FACE_BACK_BIT)
m_RenderState.back.compare = compareMask;
renderstate.back.compare = compareMask;
}
}
else
@@ -493,12 +496,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilWriteMask(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
if(faceMask & VK_STENCIL_FACE_FRONT_BIT)
m_RenderState.front.write = writeMask;
renderstate.front.write = writeMask;
if(faceMask & VK_STENCIL_FACE_BACK_BIT)
m_RenderState.back.write = writeMask;
renderstate.back.write = writeMask;
}
}
else
@@ -559,12 +562,12 @@ bool WrappedVulkan::Serialise_vkCmdSetStencilReference(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
VulkanRenderState &renderstate = GetCmdRenderState();
if(faceMask & VK_STENCIL_FACE_FRONT_BIT)
m_RenderState.front.ref = reference;
renderstate.front.ref = reference;
if(faceMask & VK_STENCIL_FACE_BACK_BIT)
m_RenderState.back.ref = reference;
renderstate.back.ref = reference;
}
}
else
@@ -623,12 +626,12 @@ bool WrappedVulkan::Serialise_vkCmdSetSampleLocationsEXT(
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.sampleLocations.locations.assign(sampleInfo.pSampleLocations,
sampleInfo.sampleLocationsCount);
m_RenderState.sampleLocations.gridSize = sampleInfo.sampleLocationGridSize;
m_RenderState.sampleLocations.sampleCount = sampleInfo.sampleLocationsPerPixel;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.sampleLocations.locations.assign(sampleInfo.pSampleLocations,
sampleInfo.sampleLocationsCount);
renderstate.sampleLocations.gridSize = sampleInfo.sampleLocationGridSize;
renderstate.sampleLocations.sampleCount = sampleInfo.sampleLocationsPerPixel;
}
}
else
@@ -691,13 +694,13 @@ bool WrappedVulkan::Serialise_vkCmdSetDiscardRectangleEXT(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
if(m_RenderState.discardRectangles.size() < firstDiscardRectangle + discardRectangleCount)
m_RenderState.discardRectangles.resize(firstDiscardRectangle + discardRectangleCount);
VulkanRenderState &renderstate = GetCmdRenderState();
if(renderstate.discardRectangles.size() < firstDiscardRectangle + discardRectangleCount)
renderstate.discardRectangles.resize(firstDiscardRectangle + discardRectangleCount);
for(uint32_t i = 0; i < discardRectangleCount; i++)
m_RenderState.discardRectangles[firstDiscardRectangle + i] = pDiscardRectangles[i];
renderstate.discardRectangles[firstDiscardRectangle + i] = pDiscardRectangles[i];
}
}
else
@@ -764,10 +767,10 @@ bool WrappedVulkan::Serialise_vkCmdSetLineStippleEXT(SerialiserType &ser,
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
if(ShouldUpdateRenderState(m_LastCmdBufferID))
{
m_RenderState.stippleFactor = lineStippleFactor;
m_RenderState.stipplePattern = lineStipplePattern;
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.stippleFactor = lineStippleFactor;
renderstate.stipplePattern = lineStipplePattern;
}
}
else