lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-22 14:36:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add support for VK_KHR_maintenance5

Browse Source
This commit is contained in:
Tristan Ritchie
2025-03-19 15:43:08 +00:00
committed by Baldur Karlsson
parent 2b01465c79
commit 2eade4650b
32 changed files with 898 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/api/replay/pipestate.inl
+1 -1
View File
@@ -515,7 +515,7 @@ BoundVBuffer PipeState::GetIBuffer() const
ret.resourceId = m_Vulkan->inputAssembly.indexBuffer.resourceId;
ret.byteOffset = m_Vulkan->inputAssembly.indexBuffer.byteOffset;
ret.byteStride = m_Vulkan->inputAssembly.indexBuffer.byteStride;
ret.byteSize = ~0ULL;
ret.byteSize = m_Vulkan->inputAssembly.indexBuffer.byteSize;
}
}
renderdoc/api/replay/vk_pipestate.h
+4 -1
View File
@@ -126,7 +126,7 @@ When not using pipeline libraries, this will be identical to :data:`pipelinePreR
)");
ResourceId pipelineFragmentLayoutResourceId;
DOCUMENT("The flags used to create the pipeline object.");
uint32_t flags = 0;
uint64_t flags = 0;
DOCUMENT(R"(The bound descriptor sets.
@@ -149,6 +149,9 @@ struct IndexBuffer
DOCUMENT("The byte offset from the start of the buffer to the beginning of the index data.");
uint64_t byteOffset = 0;
DOCUMENT("The byte size from the start offset to the end of the index data.");
uint64_t byteSize = 0;
DOCUMENT(R"(The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but
it can be 0 if no index buffer is bound.
)");
renderdoc/driver/vulkan/extension_support.md
+1 -1
View File
@@ -179,6 +179,7 @@ Maintainers can update this file by updating vk.xml in this folder and running `
* `VK_KHR_maintenance2`
* `VK_KHR_maintenance3`
* `VK_KHR_maintenance4`
* `VK_KHR_maintenance5`
* `VK_KHR_multiview`
* `VK_KHR_performance_query`
* `VK_KHR_pipeline_executable_properties`
@@ -255,7 +256,6 @@ KHR extensions will definitely be implemented at some point, though KHR extensio
## KHR Extensions
* `VK_KHR_cooperative_matrix`
* `VK_KHR_maintenance5`
* `VK_KHR_maintenance6`
* `VK_KHR_maintenance7`
* `VK_KHR_maintenance8`
renderdoc/driver/vulkan/vk_common.h
+82 -2
View File
@@ -73,6 +73,8 @@
#define VkAccessFlagBits2 VkAccessFlagBits2_VkFlags64_typedef
#define VkPipelineStageFlagBits2 VkPipelineStageFlagBits2_VkFlags64_typedef
#define VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2_VkFlags64_typedef
#define VkBufferUsageFlagBits2 VkBufferUsageFlagBits2_VkFlags64_typedef
#define VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2_VkFlags64_typedef
#include "core/core.h"
#include "core/resource_manager.h"
@@ -84,6 +86,8 @@
#undef VkAccessFlagBits2
#undef VkPipelineStageFlagBits2
#undef VkFormatFeatureFlagBits2
#undef VkBufferUsageFlagBits2
#undef VkPipelineCreateFlagBits2
#undef Bool
#undef None
@@ -129,6 +133,54 @@ int SampleIndex(VkSampleCountFlagBits countFlag);
int StageIndex(VkShaderStageFlagBits stageFlag);
VkShaderStageFlags ShaderMaskFromIndex(size_t index);
// Generic getter/setter helpers to handle optional 64 flag structs in the pNext chain
template <typename ParentStruct>
uint64_t GetBufferUsageFlags(const ParentStruct *info)
{
const VkBufferUsageFlags2CreateInfo *usage2 = (const VkBufferUsageFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
if(usage2)
return usage2->usage;
return info->usage;
}
template <typename ParentStruct>
void SetBufferUsageFlags(ParentStruct *info, uint64_t usage)
{
VkBufferUsageFlags2CreateInfo *usage2 = (VkBufferUsageFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
if(usage2)
{
usage2->usage = usage;
return;
}
info->usage = (VkBufferUsageFlags)usage;
}
template <typename ParentStruct>
uint64_t GetPipelineCreateFlags(const ParentStruct *info)
{
const VkPipelineCreateFlags2CreateInfo *flags2 =
(const VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
if(flags2)
return flags2->flags;
return info->flags;
}
template <typename ParentStruct>
void SetPipelineCreateFlags(ParentStruct *info, uint64_t flags)
{
VkPipelineCreateFlags2CreateInfo *flags2 = (VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
if(flags2)
{
flags2->flags = flags;
return;
}
info->flags = (VkPipelineCreateFlags)flags;
}
struct PackedWindowHandle
{
PackedWindowHandle(WindowingSystem s, void *h) : system(s), handle(h) {}
@@ -1150,6 +1202,7 @@ enum class VulkanChunk : uint32_t
vkCmdSetRenderingInputAttachmentIndicesKHR,
vkCmdTraceRaysIndirect2KHR,
vkCmdWriteAccelerationStructuresPropertiesKHR,
vkCmdBindIndexBuffer2KHR,
Max,
};
@@ -1233,6 +1286,7 @@ DECLARE_REFLECTION_STRUCT(VkBufferMemoryBarrier);
DECLARE_REFLECTION_STRUCT(VkBufferMemoryBarrier2);
DECLARE_REFLECTION_STRUCT(VkBufferMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkBufferOpaqueCaptureAddressCreateInfo);
DECLARE_REFLECTION_STRUCT(VkBufferUsageFlags2CreateInfo);
DECLARE_REFLECTION_STRUCT(VkBufferViewCreateInfo);
DECLARE_REFLECTION_STRUCT(VkCalibratedTimestampInfoKHR);
DECLARE_REFLECTION_STRUCT(VkCommandBufferAllocateInfo);
@@ -1286,6 +1340,7 @@ DECLARE_REFLECTION_STRUCT(VkDeviceGroupRenderPassBeginInfo);
DECLARE_REFLECTION_STRUCT(VkDeviceGroupSubmitInfo);
DECLARE_REFLECTION_STRUCT(VkDeviceGroupSwapchainCreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkDeviceImageMemoryRequirements);
DECLARE_REFLECTION_STRUCT(VkDeviceImageSubresourceInfo);
DECLARE_REFLECTION_STRUCT(VkDeviceMemoryOpaqueCaptureAddressInfo);
DECLARE_REFLECTION_STRUCT(VkDeviceMemoryOverallocationCreateInfoAMD);
DECLARE_REFLECTION_STRUCT(VkDevicePrivateDataCreateInfo);
@@ -1337,6 +1392,7 @@ DECLARE_REFLECTION_STRUCT(VkImagePlaneMemoryRequirementsInfo);
DECLARE_REFLECTION_STRUCT(VkImageResolve2);
DECLARE_REFLECTION_STRUCT(VkImageSparseMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkImageStencilUsageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageSubresource2);
DECLARE_REFLECTION_STRUCT(VkImageSwapchainCreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkImageViewASTCDecodeModeEXT);
DECLARE_REFLECTION_STRUCT(VkImageViewCreateInfo);
@@ -1438,6 +1494,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceLineRasterizationProperties);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance3Properties);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance4Features);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance4Properties);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance5Features);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance5Properties);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMemoryBudgetPropertiesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMemoryPriorityFeaturesEXT);
DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMemoryProperties2);
@@ -1540,6 +1598,7 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)
DECLARE_REFLECTION_STRUCT(VkPipelineCacheCreateInfo);
DECLARE_REFLECTION_STRUCT(VkPipelineColorBlendStateCreateInfo);
DECLARE_REFLECTION_STRUCT(VkPipelineColorWriteCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkPipelineCreateFlags2CreateInfo);
DECLARE_REFLECTION_STRUCT(VkPipelineCreationFeedbackCreateInfo);
DECLARE_REFLECTION_STRUCT(VkPipelineDepthStencilStateCreateInfo);
DECLARE_REFLECTION_STRUCT(VkPipelineDiscardRectangleStateCreateInfoEXT);
@@ -1586,6 +1645,7 @@ DECLARE_REFLECTION_STRUCT(VkRayTracingPipelineInterfaceCreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkRayTracingShaderGroupCreateInfoKHR);
DECLARE_REFLECTION_STRUCT(VkRefreshCycleDurationGOOGLE);
DECLARE_REFLECTION_STRUCT(VkReleaseSwapchainImagesInfoEXT);
DECLARE_REFLECTION_STRUCT(VkRenderingAreaInfo);
DECLARE_REFLECTION_STRUCT(VkRenderingAttachmentInfo);
DECLARE_REFLECTION_STRUCT(VkRenderingAttachmentLocationInfo);
DECLARE_REFLECTION_STRUCT(VkRenderingFragmentDensityMapAttachmentInfoEXT);
@@ -1631,6 +1691,7 @@ DECLARE_REFLECTION_STRUCT(VkSubpassEndInfo);
DECLARE_REFLECTION_STRUCT(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
DECLARE_REFLECTION_STRUCT(VkSubpassResolvePerformanceQueryEXT);
DECLARE_REFLECTION_STRUCT(VkSubpassSampleLocationsEXT);
DECLARE_REFLECTION_STRUCT(VkSubresourceLayout2);
DECLARE_REFLECTION_STRUCT(VkSurfaceCapabilities2EXT);
DECLARE_REFLECTION_STRUCT(VkSurfaceCapabilities2KHR);
DECLARE_REFLECTION_STRUCT(VkSurfaceFormat2KHR);
@@ -1688,6 +1749,7 @@ DECLARE_DESERIALISE_TYPE(VkBufferMemoryBarrier);
DECLARE_DESERIALISE_TYPE(VkBufferMemoryBarrier2);
DECLARE_DESERIALISE_TYPE(VkBufferMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfo);
DECLARE_DESERIALISE_TYPE(VkBufferUsageFlags2CreateInfo);
DECLARE_DESERIALISE_TYPE(VkBufferViewCreateInfo);
DECLARE_DESERIALISE_TYPE(VkCalibratedTimestampInfoKHR);
DECLARE_DESERIALISE_TYPE(VkCommandBufferAllocateInfo);
@@ -1741,6 +1803,7 @@ DECLARE_DESERIALISE_TYPE(VkDeviceGroupRenderPassBeginInfo);
DECLARE_DESERIALISE_TYPE(VkDeviceGroupSubmitInfo);
DECLARE_DESERIALISE_TYPE(VkDeviceGroupSwapchainCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkDeviceImageMemoryRequirements);
DECLARE_DESERIALISE_TYPE(VkDeviceImageSubresourceInfo);
DECLARE_DESERIALISE_TYPE(VkDeviceMemoryOpaqueCaptureAddressInfo);
DECLARE_DESERIALISE_TYPE(VkDeviceMemoryOverallocationCreateInfoAMD);
DECLARE_DESERIALISE_TYPE(VkDevicePrivateDataCreateInfo);
@@ -1791,6 +1854,7 @@ DECLARE_DESERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
DECLARE_DESERIALISE_TYPE(VkImageResolve2);
DECLARE_DESERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkImageStencilUsageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageSubresource2);
DECLARE_DESERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkImageViewASTCDecodeModeEXT);
DECLARE_DESERIALISE_TYPE(VkImageViewCreateInfo);
@@ -1889,6 +1953,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceLineRasterizationProperties);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance3Properties);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance4Features);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance4Properties);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance5Features);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance5Properties);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMemoryBudgetPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMemoryPriorityFeaturesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMemoryProperties2);
@@ -1974,8 +2040,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeatures);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVariablePointersFeatures);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorFeatures);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorProperties);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan11Features);
DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan11Properties);
@@ -1991,6 +2057,7 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures);
DECLARE_DESERIALISE_TYPE(VkPipelineCacheCreateInfo);
DECLARE_DESERIALISE_TYPE(VkPipelineColorBlendStateCreateInfo);
DECLARE_DESERIALISE_TYPE(VkPipelineColorWriteCreateInfoEXT);
DECLARE_DESERIALISE_TYPE(VkPipelineCreateFlags2CreateInfo);
DECLARE_DESERIALISE_TYPE(VkPipelineCreationFeedbackCreateInfo);
DECLARE_DESERIALISE_TYPE(VkPipelineDepthStencilStateCreateInfo);
DECLARE_DESERIALISE_TYPE(VkPipelineDiscardRectangleStateCreateInfoEXT);
@@ -2035,12 +2102,13 @@ DECLARE_DESERIALISE_TYPE(VkRayTracingPipelineCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkRayTracingPipelineInterfaceCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkRayTracingShaderGroupCreateInfoKHR);
DECLARE_DESERIALISE_TYPE(VkReleaseSwapchainImagesInfoEXT);
DECLARE_DESERIALISE_TYPE(VkRenderingAreaInfo);
DECLARE_DESERIALISE_TYPE(VkRenderingAttachmentInfo);
DECLARE_DESERIALISE_TYPE(VkRenderingAttachmentLocationInfo);
DECLARE_DESERIALISE_TYPE(VkRenderingFragmentDensityMapAttachmentInfoEXT);
DECLARE_DESERIALISE_TYPE(VkRenderingFragmentShadingRateAttachmentInfoKHR);
DECLARE_DESERIALISE_TYPE(VkRenderingInputAttachmentIndexInfo);
DECLARE_DESERIALISE_TYPE(VkRenderingInfo);
DECLARE_DESERIALISE_TYPE(VkRenderingInputAttachmentIndexInfo);
DECLARE_DESERIALISE_TYPE(VkRenderPassAttachmentBeginInfo);
DECLARE_DESERIALISE_TYPE(VkRenderPassBeginInfo);
DECLARE_DESERIALISE_TYPE(VkRenderPassCreateInfo);
@@ -2079,6 +2147,7 @@ DECLARE_DESERIALISE_TYPE(VkSubpassEndInfo);
DECLARE_DESERIALISE_TYPE(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
DECLARE_DESERIALISE_TYPE(VkSubpassResolvePerformanceQueryEXT);
DECLARE_DESERIALISE_TYPE(VkSubpassSampleLocationsEXT);
DECLARE_DESERIALISE_TYPE(VkSubresourceLayout2);
DECLARE_DESERIALISE_TYPE(VkSurfaceCapabilities2EXT);
DECLARE_DESERIALISE_TYPE(VkSurfaceCapabilities2KHR);
DECLARE_DESERIALISE_TYPE(VkSurfaceFormat2KHR);
@@ -2183,6 +2252,7 @@ DECLARE_REFLECTION_STRUCT(VkStencilOpState);
DECLARE_REFLECTION_STRUCT(VkStridedDeviceAddressRegionKHR);
DECLARE_REFLECTION_STRUCT(VkSubpassDependency);
DECLARE_REFLECTION_STRUCT(VkSubpassDescription);
DECLARE_REFLECTION_STRUCT(VkSubresourceLayout);
DECLARE_REFLECTION_STRUCT(VkSurfaceCapabilitiesKHR);
DECLARE_REFLECTION_STRUCT(VkSurfaceFormatKHR);
DECLARE_REFLECTION_STRUCT(VkTransformMatrixKHR);
@@ -2281,6 +2351,14 @@ enum VkFormatFeatureFlagBits2 : uint64_t
{
};
enum VkBufferUsageFlagBits2 : uint64_t
{
};
enum VkPipelineCreateFlagBits2 : uint64_t
{
};
// enums
DECLARE_REFLECTION_ENUM(VkAccelerationStructureBuildTypeKHR);
@@ -2298,6 +2376,7 @@ DECLARE_REFLECTION_ENUM(VkBlendOp);
DECLARE_REFLECTION_ENUM(VkBorderColor);
DECLARE_REFLECTION_ENUM(VkBufferCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkBufferUsageFlagBits);
DECLARE_REFLECTION_ENUM(VkBufferUsageFlagBits2);
DECLARE_REFLECTION_ENUM(VkBuildAccelerationStructureFlagBitsKHR);
DECLARE_REFLECTION_ENUM(VkBuildAccelerationStructureModeKHR);
DECLARE_REFLECTION_ENUM(VkChromaLocation);
@@ -2379,6 +2458,7 @@ DECLARE_REFLECTION_ENUM(VkPipelineBindPoint);
DECLARE_REFLECTION_ENUM(VkPipelineCacheCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkPipelineColorBlendStateCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkPipelineCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkPipelineCreateFlagBits2);
DECLARE_REFLECTION_ENUM(VkPipelineCreationFeedbackFlagBits);
DECLARE_REFLECTION_ENUM(VkPipelineDepthStencilStateCreateFlagBits);
DECLARE_REFLECTION_ENUM(VkPipelineExecutableStatisticFormatKHR);
renderdoc/driver/vulkan/vk_core.cpp
+7
View File
@@ -1626,6 +1626,10 @@ static const VkExtensionProperties supportedExtensions[] = {
VK_KHR_MAINTENANCE_4_EXTENSION_NAME,
VK_KHR_MAINTENANCE_4_SPEC_VERSION,
},
{
VK_KHR_MAINTENANCE_5_EXTENSION_NAME,
VK_KHR_MAINTENANCE_5_SPEC_VERSION,
},
{
VK_KHR_MULTIVIEW_EXTENSION_NAME,
VK_KHR_MULTIVIEW_SPEC_VERSION,
@@ -4365,6 +4369,9 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
case VulkanChunk::vkCmdWriteAccelerationStructuresPropertiesKHR:
return Serialise_vkCmdWriteAccelerationStructuresPropertiesKHR(
ser, VK_NULL_HANDLE, 0, NULL, VK_QUERY_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0);
case VulkanChunk::vkCmdBindIndexBuffer2KHR:
return Serialise_vkCmdBindIndexBuffer2KHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0,
VK_INDEX_TYPE_MAX_ENUM);
// chunks that are reserved but not yet serialised
case VulkanChunk::vkResetCommandPool:
renderdoc/driver/vulkan/vk_core.h
+17
View File
@@ -484,6 +484,7 @@ private:
bool m_ListRestart = false;
bool m_AccelerationStructures = false;
bool m_ShaderObject = false;
bool m_Maintenance5 = false;
uint32_t m_RTCaptureReplayHandleSize = 0;
@@ -1024,6 +1025,7 @@ private:
VkSampleCountFlagBits samples);
void PatchImageViewUsage(VkImageViewUsageCreateInfo *usage, VkFormat imgFormat,
VkSampleCountFlagBits samples);
void PatchImageCreateInfo(VkImageCreateInfo *pInfo, VkFormat *newViewFormats);
VkIndirectPatchData FetchIndirectData(VkIndirectPatchType type, VkCommandBuffer commandBuffer,
VkBuffer dataBuffer, VkDeviceSize dataOffset, uint32_t count,
@@ -1378,6 +1380,7 @@ public:
bool ListRestart() const { return m_ListRestart; }
bool AccelerationStructures() const { return m_AccelerationStructures; }
bool ShaderObject() const { return m_ShaderObject; }
bool Maintenance5() const { return m_Maintenance5; }
VulkanRenderState &GetRenderState() { return m_RenderState; }
void SetActionCB(VulkanActionCallback *cb) { m_ActionCallback = cb; }
void SetSubmitChain(void *submitChain) { m_SubmitChain = submitChain; }
@@ -3028,4 +3031,18 @@ public:
// VK_KHR_ray_tracing_maintenance1
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdTraceRaysIndirect2KHR, VkCommandBuffer commandBuffer,
VkDeviceAddress indirectDeviceAddress);
// VK_KHR_maintenance5
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer commandBuffer,
VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
VkIndexType indexType);
void vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
const VkDeviceImageSubresourceInfo *pInfo,
VkSubresourceLayout2 *pLayout);
void vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
const VkImageSubresource2 *pSubresource,
VkSubresourceLayout2 *pLayout);
void vkGetRenderingAreaGranularityKHR(VkDevice device,
const VkRenderingAreaInfo *pRenderingAreaInfo,
VkExtent2D *pGranularity);
};
renderdoc/driver/vulkan/vk_hookset_defs.h
+16 -2
View File
@@ -545,7 +545,8 @@
DeclExt(EXT_shader_subgroup_ballot); \
DeclExt(EXT_shader_subgroup_vote); \
DeclExt(KHR_shader_subgroup_uniform_control_flow); \
DeclExt(KHR_ray_tracing_maintenance1);
DeclExt(KHR_ray_tracing_maintenance1); \
DeclExt(KHR_maintenance5);
// for simplicity and since the check itself is platform agnostic,
// these aren't protected in platform defines
@@ -680,7 +681,8 @@
CheckExt(EXT_shader_subgroup_ballot, VK11); \
CheckExt(EXT_shader_subgroup_vote, VK11); \
CheckExt(KHR_shader_subgroup_uniform_control_flow, VKXX); \
CheckExt(KHR_ray_tracing_maintenance1, VKXX);
CheckExt(KHR_ray_tracing_maintenance1, VKXX); \
CheckExt(KHR_maintenance5, VKXX);
#define HookInitVulkanInstanceExts_PhysDev() \
HookInitExtension(KHR_surface, GetPhysicalDeviceSurfaceSupportKHR); \
@@ -1047,6 +1049,10 @@
HookInitExtension(KHR_ray_tracing_pipeline, GetRayTracingShaderGroupHandlesKHR); \
HookInitExtension(KHR_ray_tracing_pipeline, GetRayTracingShaderGroupStackSizeKHR); \
HookInitExtension(KHR_ray_tracing_maintenance1, CmdTraceRaysIndirect2KHR); \
HookInitExtension(KHR_maintenance5, CmdBindIndexBuffer2KHR); \
HookInitExtension(KHR_maintenance5, GetDeviceImageSubresourceLayoutKHR); \
HookInitExtension(KHR_maintenance5, GetImageSubresourceLayout2KHR); \
HookInitExtension(KHR_maintenance5, GetRenderingAreaGranularityKHR); \
HookInitExtension_Device_Win32(); \
HookInitExtension_Device_Linux(); \
HookInitExtension_Device_Android(); \
@@ -1954,6 +1960,14 @@
uint32_t, pipelineStackSize); \
HookDefine2(void, vkCmdTraceRaysIndirect2KHR, VkCommandBuffer, commandBuffer, VkDeviceAddress, \
indirectDeviceAddress); \
HookDefine5(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer, commandBuffer, VkBuffer, buffer, \
VkDeviceSize, offset, VkDeviceSize, size, VkIndexType, indexType); \
HookDefine3(void, vkGetDeviceImageSubresourceLayoutKHR, VkDevice, device, \
const VkDeviceImageSubresourceInfo *, pInfo, VkSubresourceLayout2 *, pLayout); \
HookDefine4(void, vkGetImageSubresourceLayout2KHR, VkDevice, device, VkImage, image, \
const VkImageSubresource2 *, pSubresource, VkSubresourceLayout2 *, pLayout); \
HookDefine3(void, vkGetRenderingAreaGranularityKHR, VkDevice, device, \
const VkRenderingAreaInfo *, pRenderingAreaInfo, VkExtent2D *, pGranularity); \
HookDefine_Win32(); \
HookDefine_Linux(); \
HookDefine_Android(); \
renderdoc/driver/vulkan/vk_info.cpp
+18 -3
View File
@@ -1075,7 +1075,12 @@ void VulkanCreationInfo::Pipeline::Init(VulkanResourceManager *resourceMan,
VulkanCreationInfo &info, ResourceId id,
const VkGraphicsPipelineCreateInfo *pCreateInfo)
{
flags = pCreateInfo->flags;
const VkPipelineCreateFlags2CreateInfo *createFlags2 =
(const VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
flags = createFlags2 ? createFlags2->flags : pCreateInfo->flags;
useCreateFlags2 = createFlags2 != NULL;
graphicsPipe = true;
@@ -1768,7 +1773,12 @@ void VulkanCreationInfo::Pipeline::Init(VulkanResourceManager *resourceMan,
void VulkanCreationInfo::Pipeline::Init(VulkanResourceManager *resourceMan, VulkanCreationInfo &info,
ResourceId id, const VkComputePipelineCreateInfo *pCreateInfo)
{
flags = pCreateInfo->flags;
const VkPipelineCreateFlags2CreateInfo *createFlags2 =
(const VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
flags = createFlags2 ? createFlags2->flags : pCreateInfo->flags;
useCreateFlags2 = createFlags2 != NULL;
graphicsPipe = false;
@@ -1880,7 +1890,12 @@ void VulkanCreationInfo::Pipeline::Init(VulkanResourceManager *resourceMan,
VulkanCreationInfo &info, ResourceId id,
const VkRayTracingPipelineCreateInfoKHR *pCreateInfo)
{
flags = pCreateInfo->flags;
const VkPipelineCreateFlags2CreateInfo *createFlags2 =
(const VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
flags = createFlags2 ? createFlags2->flags : pCreateInfo->flags;
useCreateFlags2 = createFlags2 != NULL;
graphicsPipe = false;
renderdoc/driver/vulkan/vk_info.h
+5 -2
View File
@@ -300,7 +300,10 @@ struct VulkanCreationInfo
VkPipeline subpass0pipe;
// VkGraphicsPipelineCreateInfo
VkPipelineCreateFlags flags;
uint64_t flags;
// VkPipelineCreateFlags2CreateInfo
bool useCreateFlags2;
// VkPipelineShaderStageCreateInfo
ShaderEntry shaders[NumShaderStages];
@@ -597,7 +600,7 @@ struct VulkanCreationInfo
void Init(VulkanResourceManager *resourceMan, VulkanCreationInfo &info,
const VkBufferCreateInfo *pCreateInfo, VkMemoryRequirements origMrq);
VkBufferUsageFlags usage;
uint64_t usage;
uint64_t size;
uint64_t gpuAddress;
bool external;
renderdoc/driver/vulkan/vk_next_chains.cpp
+44 -11
View File
@@ -120,6 +120,7 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, VkBufferImageCopy2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, \
VkBufferOpaqueCaptureAddressCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, VkBufferUsageFlags2CreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, VkCalibratedTimestampInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, VkCommandBufferBeginInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, \
@@ -193,6 +194,7 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, \
VkImagePlaneMemoryRequirementsInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, VkImageResolve2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, VkImageSubresource2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VkImageStencilUsageCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, VkImageViewASTCDecodeModeEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, VkImageViewMinLodCreateInfoEXT); \
@@ -351,6 +353,10 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
VkPhysicalDeviceMaintenance4Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, \
VkPhysicalDeviceMaintenance4Properties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, \
VkPhysicalDeviceMaintenance5Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, \
VkPhysicalDeviceMaintenance5Properties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, \
VkPhysicalDeviceMemoryBudgetPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, \
@@ -556,6 +562,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
VkPipelineColorBlendStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, \
VkPipelineColorWriteCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, \
VkPipelineCreateFlags2CreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, \
VkPipelineDepthStencilStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, \
@@ -655,6 +663,7 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_END_INFO, VkSubpassEndInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, \
VkSubpassResolvePerformanceQueryEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, VkSubresourceLayout2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, VkSurfaceCapabilities2EXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, VkSurfaceCapabilities2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, VkSurfaceFormat2KHR); \
@@ -685,6 +694,7 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
VkWriteDescriptorSetInlineUniformBlock); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, \
VkRenderingAttachmentLocationInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, VkRenderingAreaInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, \
VkRenderingInputAttachmentIndexInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, \
@@ -871,7 +881,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: \
case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: \
case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: \
case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: \
@@ -915,7 +924,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: \
case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: \
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: \
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: \
case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: \
case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: \
@@ -962,7 +970,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: \
case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: \
@@ -1102,8 +1109,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: \
@@ -1190,7 +1195,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: \
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: \
@@ -1227,7 +1231,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: \
case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: \
case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: \
case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: \
case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: \
case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: \
@@ -1242,7 +1245,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: \
case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: \
case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: \
case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: \
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: \
case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: \
@@ -1521,6 +1523,15 @@ size_t GetNextPatchSize(const void *pNext)
memSize += GetNextPatchSize(info->pCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
{
memSize += sizeof(VkDeviceImageSubresourceInfo);
VkDeviceImageSubresourceInfo *info = (VkDeviceImageSubresourceInfo *)next;
memSize += GetNextPatchSize(info->pCreateInfo);
memSize += GetNextPatchSize(info->pSubresource);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
{
memSize += sizeof(VkFramebufferCreateInfo);
@@ -2190,7 +2201,7 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
*out = *in;
UnwrapInPlace(out->layout);
UnwrapInPlace(out->stage.module);
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(out) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
@@ -2454,6 +2465,24 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
break;
}
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
{
const VkDeviceImageSubresourceInfo *in = (const VkDeviceImageSubresourceInfo *)nextInput;
VkDeviceImageSubresourceInfo *out = (VkDeviceImageSubresourceInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
*out = *in;
out->pCreateInfo = AllocStructCopy(tempMem, in->pCreateInfo);
UnwrapNextChain(state, "VkImageCreateInfo", tempMem, (VkBaseInStructure *)out->pCreateInfo);
out->pSubresource = AllocStructCopy(tempMem, in->pSubresource);
UnwrapNextChain(state, "VkImageSubresource2", tempMem,
(VkBaseInStructure *)out->pSubresource);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
{
const VkFramebufferCreateInfo *in = (const VkFramebufferCreateInfo *)nextInput;
@@ -2584,7 +2613,7 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
out->layout = Unwrap(in->layout);
out->renderPass = Unwrap(in->renderPass);
out->subpass = in->subpass;
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(out) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
out->basePipelineHandle = Unwrap(in->basePipelineHandle);
else
out->basePipelineHandle = VK_NULL_HANDLE;
@@ -2733,7 +2762,7 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
UnwrapNextChain(state, "VkPipelineDynamicStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pDynamicState);
UnwrapInPlace(out->layout);
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(out) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
else
out->basePipelineHandle = VK_NULL_HANDLE;
@@ -3332,6 +3361,10 @@ void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInSt
CopyNextChainedStruct(sizeof(VkDeviceImageMemoryRequirements), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
CopyNextChainedStruct(sizeof(VkDeviceImageSubresourceInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkFramebufferCreateInfo), tempMem, nextInput, nextChainTail);
break;
renderdoc/driver/vulkan/vk_overlay.cpp
+11 -1
View File
@@ -558,9 +558,19 @@ void VulkanDebugManager::PatchLineStripIndexBuffer(const ActionDescription *acti
if(action->flags & ActionFlags::Indexed)
{
uint64_t readSizeBytes = uint64_t(action->numIndices) * rs.ibuffer.bytewidth;
// clamp to handle subrange bound via vkCmdBindIndexBuffer2
if(rs.ibuffer.size != VK_WHOLE_SIZE)
{
uint64_t offsetBytes = uint64_t(action->indexOffset) * rs.ibuffer.bytewidth;
uint64_t maxSubrangeBytes = rs.ibuffer.size > offsetBytes ? rs.ibuffer.size - offsetBytes : 0;
readSizeBytes = RDCMIN(readSizeBytes, maxSubrangeBytes);
}
GetBufferData(rs.ibuffer.buf,
rs.ibuffer.offs + uint64_t(action->indexOffset) * rs.ibuffer.bytewidth,
uint64_t(action->numIndices) * rs.ibuffer.bytewidth, indices);
readSizeBytes, indices);
if(rs.ibuffer.bytewidth == 4)
idx32 = (uint32_t *)indices.data();
renderdoc/driver/vulkan/vk_postvs.cpp
+14 -1
View File
@@ -4228,8 +4228,21 @@ void VulkanReplay::FetchVSOut(uint32_t eventId, VulkanRenderState &state)
// fetch ibuffer
if(state.ibuffer.buf != ResourceId())
{
uint64_t readSizeBytes = uint64_t(action->numIndices) * state.ibuffer.bytewidth;
// clamp to handle subrange bound via vkCmdBindIndexBuffer2
if(state.ibuffer.size != VK_WHOLE_SIZE)
{
uint64_t offsetBytes = uint64_t(action->indexOffset) * state.ibuffer.bytewidth;
uint64_t maxSubrangeBytes =
state.ibuffer.size > offsetBytes ? state.ibuffer.size - offsetBytes : 0;
readSizeBytes = RDCMIN(readSizeBytes, maxSubrangeBytes);
}
GetBufferData(state.ibuffer.buf, state.ibuffer.offs + action->indexOffset * idxsize,
uint64_t(action->numIndices) * idxsize, idxdata);
readSizeBytes, idxdata);
}
// figure out what the maximum index could be, so we can clamp our index buffer to something
// sane
renderdoc/driver/vulkan/vk_replay.cpp
+9 -4
View File
@@ -1331,6 +1331,7 @@ void VulkanReplay::SavePipelineState(uint32_t eventId)
// Input Assembly
ret.inputAssembly.indexBuffer.resourceId = rm->GetOriginalID(state.ibuffer.buf);
ret.inputAssembly.indexBuffer.byteOffset = state.ibuffer.offs;
ret.inputAssembly.indexBuffer.byteSize = state.ibuffer.size;
ret.inputAssembly.indexBuffer.byteStride = state.ibuffer.bytewidth;
ret.inputAssembly.primitiveRestartEnable = state.primRestartEnable != VK_FALSE;
ret.inputAssembly.topology =
@@ -5062,8 +5063,10 @@ void VulkanReplay::RefreshDerivedReplacements()
// if we have pipeline executable properties, capture the data
if(m_pDriver->GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
{
pipeCreateInfo.flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
uint64_t flags = GetPipelineCreateFlags(&pipeCreateInfo);
flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
SetPipelineCreateFlags(&pipeCreateInfo, flags);
}
// create the new graphics pipeline
@@ -5110,8 +5113,10 @@ void VulkanReplay::RefreshDerivedReplacements()
// if we have pipeline executable properties, capture the data
if(m_pDriver->GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
{
pipeCreateInfo.flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
uint64_t flags = GetPipelineCreateFlags(&pipeCreateInfo);
flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
SetPipelineCreateFlags(&pipeCreateInfo, flags);
}
// create the new compute pipeline
renderdoc/driver/vulkan/vk_resources.cpp
+13 -2
View File
@@ -1466,6 +1466,7 @@ BlockShape GetBlockShape(VkFormat Format, uint32_t plane)
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
@@ -1479,7 +1480,8 @@ BlockShape GetBlockShape(VkFormat Format, uint32_t plane)
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_S8_UINT: return {1, 1, 1};
case VK_FORMAT_S8_UINT:
case VK_FORMAT_A8_UNORM: return {1, 1, 1};
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
@@ -1819,7 +1821,8 @@ ResourceFormat MakeResourceFormat(VkFormat fmt)
case VK_FORMAT_B5G6R5_UNORM_PACK16: ret.type = ResourceFormatType::R5G6B5; break;
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16: ret.type = ResourceFormatType::R5G5B5A1; break;
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
case VK_FORMAT_A1B5G5R5_UNORM_PACK16: ret.type = ResourceFormatType::R5G5B5A1; break;
case VK_FORMAT_D16_UNORM_S8_UINT: ret.type = ResourceFormatType::D16S8; break;
case VK_FORMAT_D24_UNORM_S8_UINT: ret.type = ResourceFormatType::D24S8; break;
case VK_FORMAT_D32_SFLOAT_S8_UINT: ret.type = ResourceFormatType::D32S8; break;
@@ -1942,6 +1945,7 @@ ResourceFormat MakeResourceFormat(VkFormat fmt)
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: ret.type = ResourceFormatType::YUV16; break;
case VK_FORMAT_A8_UNORM: ret.type = ResourceFormatType::A8; break;
default: break;
}
@@ -2890,6 +2894,7 @@ VkFormat MakeVkFormat(ResourceFormat fmt)
case ResourceFormatType::D24S8: ret = VK_FORMAT_D24_UNORM_S8_UINT; break;
case ResourceFormatType::D32S8: ret = VK_FORMAT_D32_SFLOAT_S8_UINT; break;
case ResourceFormatType::S8: ret = VK_FORMAT_S8_UINT; break;
case ResourceFormatType::A8: ret = VK_FORMAT_A8_UNORM; break;
case ResourceFormatType::YUV8:
{
int subsampling = fmt.YUVSubsampling();
@@ -4327,6 +4332,7 @@ TEST_CASE("Vulkan formats", "[format][vulkan]")
VK_FORMAT_R5G5B5A1_UNORM_PACK16,
VK_FORMAT_B5G5R5A1_UNORM_PACK16,
VK_FORMAT_A1R5G5B5_UNORM_PACK16,
VK_FORMAT_A1B5G5R5_UNORM_PACK16,
VK_FORMAT_R8_UNORM,
VK_FORMAT_R8_SNORM,
VK_FORMAT_R8_USCALED,
@@ -4334,6 +4340,7 @@ TEST_CASE("Vulkan formats", "[format][vulkan]")
VK_FORMAT_R8_UINT,
VK_FORMAT_R8_SINT,
VK_FORMAT_R8_SRGB,
VK_FORMAT_A8_UNORM,
VK_FORMAT_R8G8_UNORM,
VK_FORMAT_R8G8_SNORM,
VK_FORMAT_R8G8_USCALED,
@@ -4607,6 +4614,10 @@ TEST_CASE("Vulkan formats", "[format][vulkan]")
{
CHECK(reconstructed == VK_FORMAT_R5G5B5A1_UNORM_PACK16);
}
else if(f == VK_FORMAT_A1B5G5R5_UNORM_PACK16)
{
CHECK(reconstructed == VK_FORMAT_B5G5R5A1_UNORM_PACK16);
}
else if(f == VK_FORMAT_A8B8G8R8_UNORM_PACK32)
{
CHECK(reconstructed == VK_FORMAT_R8G8B8A8_UNORM);
renderdoc/driver/vulkan/vk_serialise.cpp
+172 -14
View File
@@ -169,6 +169,8 @@ DECL_VKFLAG_EXT(VkBuildAccelerationStructure, KHR);
DECL_VKFLAG_EXT(VkGeometry, KHR);
DECL_VKFLAG_EXT(VkGeometryInstance, KHR);
DECL_VKFLAG_EXT(VkShaderCreate, EXT);
DECL_VKFLAG_EXT(VkBufferUsage, 2);
DECL_VKFLAG_EXT(VkPipelineCreate, 2);
// serialise a member as flags - cast to the Bits enum for serialisation so the stringification
// picks up the bitfield and doesn't treat it as uint32_t. Then we rename the type back to the base
@@ -1234,6 +1236,19 @@ SERIALISE_VK_HANDLES();
PNEXT_STRUCT(VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, VkDeviceBufferMemoryRequirements) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, VkDeviceImageMemoryRequirements) \
\
/* VK_KHR_maintenance5 */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, VkDeviceImageSubresourceInfo) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, VkImageSubresource2) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, VkRenderingAreaInfo) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, VkSubresourceLayout2) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, VkBufferUsageFlags2CreateInfo) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, \
VkPipelineCreateFlags2CreateInfo) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, \
VkPhysicalDeviceMaintenance5Features) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, \
VkPhysicalDeviceMaintenance5Properties) \
\
/* VK_EXT_multisampled_render_to_single_sampled */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, \
VkMultisampledRenderToSingleSampledInfoEXT) \
@@ -1659,8 +1674,6 @@ SERIALISE_VK_HANDLES();
/* VK_EXT_image_compression_control */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT) \
\
/* VK_EXT_image_compression_control_swapchain */ \
@@ -1803,14 +1816,6 @@ SERIALISE_VK_HANDLES();
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO) \
\
/* VK_KHR_maintenance5 */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO) \
\
/* VK_KHR_maintenance6 */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES) \
@@ -4051,7 +4056,7 @@ void DoSerialise(SerialiserType &ser, VkGraphicsPipelineCreateInfo &el)
SERIALISE_MEMBER(subpass);
// handle must be explicitly ignored if the flag isn't set, since it could be garbage
if(el.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&el) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
SERIALISE_MEMBER(basePipelineHandle);
}
@@ -4132,7 +4137,7 @@ void DoSerialise(SerialiserType &ser, VkComputePipelineCreateInfo &el)
SERIALISE_MEMBER(stage).Important();
SERIALISE_MEMBER(layout);
if(el.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&el) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
SERIALISE_MEMBER(basePipelineHandle);
else
SERIALISE_MEMBER_EMPTY(basePipelineHandle);
@@ -12629,7 +12634,7 @@ void DoSerialise(SerialiserType &ser, VkRayTracingPipelineCreateInfoKHR &el)
SERIALISE_MEMBER_OPT(pDynamicState);
SERIALISE_MEMBER(layout);
if(el.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&el) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
SERIALISE_MEMBER(basePipelineHandle);
else
SERIALISE_MEMBER_EMPTY(basePipelineHandle);
@@ -12805,6 +12810,150 @@ void DoSerialise(SerialiserType &ser, VkAccelerationStructureInfo &el)
INSTANTIATE_SERIALISE_TYPE(VkAccelerationStructureInfo);
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkSubresourceLayout &el)
{
SERIALISE_MEMBER(offset);
SERIALISE_MEMBER(size);
SERIALISE_MEMBER(rowPitch);
SERIALISE_MEMBER(arrayPitch);
SERIALISE_MEMBER(depthPitch);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkDeviceImageSubresourceInfo &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_OPT(pCreateInfo);
SERIALISE_MEMBER_OPT(pSubresource);
}
template <>
void Deserialise(const VkDeviceImageSubresourceInfo &el)
{
DeserialiseNext(el.pNext);
delete el.pCreateInfo;
delete el.pSubresource;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageSubresource2 &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(imageSubresource);
}
template <>
void Deserialise(const VkImageSubresource2 &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkRenderingAreaInfo &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_RENDERING_AREA_INFO);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(viewMask);
SERIALISE_MEMBER(colorAttachmentCount);
SERIALISE_MEMBER_ARRAY(pColorAttachmentFormats, colorAttachmentCount);
SERIALISE_MEMBER(depthAttachmentFormat);
SERIALISE_MEMBER(stencilAttachmentFormat);
}
template <>
void Deserialise(const VkRenderingAreaInfo &el)
{
DeserialiseNext(el.pNext);
delete[] el.pColorAttachmentFormats;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkSubresourceLayout2 &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(subresourceLayout);
}
template <>
void Deserialise(const VkSubresourceLayout2 &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkBufferUsageFlags2CreateInfo &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkBufferUsageFlags2, usage);
}
template <>
void Deserialise(const VkBufferUsageFlags2CreateInfo &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkPipelineCreateFlags2CreateInfo &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER_VKFLAGS(VkPipelineCreateFlags2, flags);
}
template <>
void Deserialise(const VkPipelineCreateFlags2CreateInfo &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance5Features &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(maintenance5);
}
template <>
void Deserialise(const VkPhysicalDeviceMaintenance5Features &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance5Properties &el)
{
RDCASSERT(ser.IsReading() ||
el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(earlyFragmentMultisampleCoverageAfterSampleCounting);
SERIALISE_MEMBER(earlyFragmentSampleMaskTestBeforeSampleCounting);
SERIALISE_MEMBER(depthStencilSwizzleOneSupport);
SERIALISE_MEMBER(polygonModePointSize);
SERIALISE_MEMBER(nonStrictSinglePixelWideLinesUseParallelogram);
SERIALISE_MEMBER(nonStrictWideLinesUseParallelogram);
}
template <>
void Deserialise(const VkPhysicalDeviceMaintenance5Properties &el)
{
DeserialiseNext(el.pNext);
}
// pNext structs - always have deserialise for the next chain
INSTANTIATE_SERIALISE_TYPE(VkAccelerationStructureBuildGeometryInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkAccelerationStructureBuildSizesInfoKHR);
@@ -12840,6 +12989,7 @@ INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryBarrier);
INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryBarrier2);
INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkBufferUsageFlags2CreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkBufferViewCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkCalibratedTimestampInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkCommandBufferAllocateInfo);
@@ -12892,6 +13042,7 @@ INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupRenderPassBeginInfo);
INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupSubmitInfo);
INSTANTIATE_SERIALISE_TYPE(VkDeviceGroupSwapchainCreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkDeviceImageMemoryRequirements);
INSTANTIATE_SERIALISE_TYPE(VkDeviceImageSubresourceInfo);
INSTANTIATE_SERIALISE_TYPE(VkDeviceMemoryOpaqueCaptureAddressInfo);
INSTANTIATE_SERIALISE_TYPE(VkDeviceMemoryOverallocationCreateInfoAMD);
INSTANTIATE_SERIALISE_TYPE(VkDevicePrivateDataCreateInfo);
@@ -12943,6 +13094,7 @@ INSTANTIATE_SERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageResolve2);
INSTANTIATE_SERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkImageStencilUsageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageSubresource2);
INSTANTIATE_SERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkImageViewASTCDecodeModeEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageViewCreateInfo);
@@ -13040,6 +13192,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceLineRasterizationProperties);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance3Properties);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance4Features);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance4Properties);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance5Features);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance5Properties);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMemoryBudgetPropertiesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMemoryPriorityFeaturesEXT);
INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMemoryProperties2);
@@ -13142,6 +13296,7 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
INSTANTIATE_SERIALISE_TYPE(VkPipelineCacheCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkPipelineColorBlendStateCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkPipelineColorWriteCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkPipelineCreateFlags2CreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkPipelineCreationFeedbackCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkPipelineDepthStencilStateCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkPipelineDiscardRectangleStateCreateInfoEXT);
@@ -13188,11 +13343,12 @@ INSTANTIATE_SERIALISE_TYPE(VkRayTracingPipelineInterfaceCreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkRayTracingShaderGroupCreateInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkRefreshCycleDurationGOOGLE);
INSTANTIATE_SERIALISE_TYPE(VkReleaseSwapchainImagesInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkRenderingAreaInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderingAttachmentInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderingAttachmentLocationInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderingFragmentDensityMapAttachmentInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkRenderingFragmentShadingRateAttachmentInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkRenderingInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderingAttachmentLocationInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderingInputAttachmentIndexInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderPassAttachmentBeginInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderPassBeginInfo);
@@ -13233,6 +13389,7 @@ INSTANTIATE_SERIALISE_TYPE(VkSubpassEndInfo);
INSTANTIATE_SERIALISE_TYPE(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
INSTANTIATE_SERIALISE_TYPE(VkSubpassResolvePerformanceQueryEXT);
INSTANTIATE_SERIALISE_TYPE(VkSubpassSampleLocationsEXT);
INSTANTIATE_SERIALISE_TYPE(VkSubresourceLayout2);
INSTANTIATE_SERIALISE_TYPE(VkSurfaceCapabilities2EXT);
INSTANTIATE_SERIALISE_TYPE(VkSurfaceCapabilities2KHR);
INSTANTIATE_SERIALISE_TYPE(VkSurfaceFormat2KHR);
@@ -13334,6 +13491,7 @@ INSTANTIATE_SERIALISE_TYPE(VkStencilOpState);
INSTANTIATE_SERIALISE_TYPE(VkStridedDeviceAddressRegionKHR);
INSTANTIATE_SERIALISE_TYPE(VkSubpassDependency);
INSTANTIATE_SERIALISE_TYPE(VkSubpassDescription);
INSTANTIATE_SERIALISE_TYPE(VkSubresourceLayout);
INSTANTIATE_SERIALISE_TYPE(VkSurfaceCapabilitiesKHR);
INSTANTIATE_SERIALISE_TYPE(VkSurfaceFormatKHR);
INSTANTIATE_SERIALISE_TYPE(VkTransformMatrixKHR);
renderdoc/driver/vulkan/vk_shader_cache.cpp
+40 -6
View File
@@ -941,7 +941,7 @@ void VulkanShaderCache::MakeGraphicsPipelineInfo(VkGraphicsPipelineCreateInfo &p
VkGraphicsPipelineCreateInfo ret = {
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
NULL,
pipeInfo.flags,
0,
stageCount,
stages,
&vi,
@@ -1056,11 +1056,28 @@ void VulkanShaderCache::MakeGraphicsPipelineInfo(VkGraphicsPipelineCreateInfo &p
rs.pNext = &provokeSetup;
}
uint64_t flags = pipeInfo.flags;
// never create derivatives
ret.flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
ret.flags &= ~VK_PIPELINE_CREATE_LIBRARY_BIT_KHR;
ret.flags &= ~VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
flags &= ~VK_PIPELINE_CREATE_LIBRARY_BIT_KHR;
flags &= ~VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
static VkPipelineCreateFlags2CreateInfo createFlags = {
VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
};
if(pipeInfo.useCreateFlags2 && m_pDriver->Maintenance5())
{
createFlags.flags = flags;
createFlags.pNext = rs.pNext;
rs.pNext = &createFlags;
}
else
{
rs.flags = (uint32_t)flags;
}
pipeCreateInfo = ret;
}
@@ -1132,15 +1149,32 @@ void VulkanShaderCache::MakeComputePipelineInfo(VkComputePipelineCreateInfo &pip
VkComputePipelineCreateInfo ret = {
VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
NULL,
pipeInfo.flags,
0,
stage,
rm->GetCurrentHandle<VkPipelineLayout>(pipeInfo.compLayout),
VK_NULL_HANDLE, // base pipeline handle
0, // base pipeline index
};
uint64_t flags = pipeInfo.flags;
// never create derivatives
ret.flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
static VkPipelineCreateFlags2CreateInfo createFlags = {
VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
};
if(pipeInfo.useCreateFlags2 && m_pDriver->Maintenance5())
{
createFlags.flags = flags;
createFlags.pNext = ret.pNext;
ret.pNext = &createFlags;
}
else
{
ret.flags = (uint32_t)flags;
}
pipeCreateInfo = ret;
}
renderdoc/driver/vulkan/vk_state.cpp
+8 -3
View File
@@ -707,9 +707,14 @@ void VulkanRenderState::BindDynamicState(WrappedVulkan *vk, VkCommandBuffer cmd)
else if(ibuffer.bytewidth == 1)
type = VK_INDEX_TYPE_UINT8;
ObjDisp(cmd)->CmdBindIndexBuffer(
Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
ibuffer.offs, type);
if(vk->Maintenance5() && ibuffer.size != VK_WHOLE_SIZE)
ObjDisp(cmd)->CmdBindIndexBuffer2KHR(
Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
ibuffer.offs, ibuffer.size, type);
else
ObjDisp(cmd)->CmdBindIndexBuffer(
Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
ibuffer.offs, type);
}
if((vk->DynamicVertexInput() || vk->ShaderObject()) && dynamicStates[VkDynamicVertexInputEXT])
renderdoc/driver/vulkan/vk_state.h
+1
View File
@@ -185,6 +185,7 @@ struct VulkanRenderState
{
ResourceId buf;
VkDeviceSize offs = 0;
VkDeviceSize size = VK_WHOLE_SIZE;
int bytewidth = 0;
} ibuffer;
renderdoc/driver/vulkan/vk_stringise.cpp
+79 -1
View File
@@ -28,7 +28,7 @@
template <>
rdcstr DoStringise(const VulkanChunk &el)
{
RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1217, "Chunks changed without updating names");
RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1218, "Chunks changed without updating names");
BEGIN_ENUM_STRINGISE(VulkanChunk)
{
@@ -249,6 +249,7 @@ rdcstr DoStringise(const VulkanChunk &el)
STRINGISE_ENUM_CLASS(vkCmdSetRenderingInputAttachmentIndicesKHR)
STRINGISE_ENUM_CLASS(vkCmdTraceRaysIndirect2KHR)
STRINGISE_ENUM_CLASS(vkCmdWriteAccelerationStructuresPropertiesKHR)
STRINGISE_ENUM_CLASS(vkCmdBindIndexBuffer2KHR)
STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk");
}
END_ENUM_STRINGISE()
@@ -4086,6 +4087,83 @@ rdcstr DoStringise(const VkMemoryUnmapFlagBits &el)
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkBufferUsageFlagBits2 &el)
{
BEGIN_BITFIELD_STRINGISE(VkBufferUsageFlagBits2);
{
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_TRANSFER_DST_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT);
}
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkPipelineCreateFlagBits2 &el)
{
BEGIN_BITFIELD_STRINGISE(VkPipelineCreateFlagBits2);
{
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR);
STRINGISE_BITFIELD_BIT64(
VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV);
STRINGISE_BITFIELD_BIT64(VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT);
}
END_BITFIELD_STRINGISE();
}
template <>
rdcstr DoStringise(const VkExtent3D &el)
{
renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp
+93
View File
@@ -3875,6 +3875,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser,
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.ibuffer.buf = GetResID(buffer);
renderstate.ibuffer.offs = offset;
renderstate.ibuffer.size = VK_WHOLE_SIZE;
if(indexType == VK_INDEX_TYPE_UINT32)
renderstate.ibuffer.bytewidth = 4;
@@ -8513,6 +8514,94 @@ void WrappedVulkan::vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
VkCommandBuffer commandBuffer,
VkBuffer buffer, VkDeviceSize offset,
VkDeviceSize size, VkIndexType indexType)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT(buffer).Important();
SERIALISE_ELEMENT(offset).OffsetOrSize();
SERIALISE_ELEMENT(size).OffsetOrSize();
SERIALISE_ELEMENT(indexType).Important();
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
ObjDisp(commandBuffer)
->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
{
VulkanRenderState &renderstate = GetCmdRenderState();
renderstate.ibuffer.buf = GetResID(buffer);
renderstate.ibuffer.offs = offset;
renderstate.ibuffer.size = size;
if(indexType == VK_INDEX_TYPE_UINT32)
renderstate.ibuffer.bytewidth = 4;
else if(indexType == VK_INDEX_TYPE_UINT8_KHR)
renderstate.ibuffer.bytewidth = 1;
else
renderstate.ibuffer.bytewidth = 2;
}
}
}
else
{
// track while reading, as we need to bind current topology & index byte width in AddAction
if(indexType == VK_INDEX_TYPE_UINT32)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 4;
else if(indexType == VK_INDEX_TYPE_UINT8_KHR)
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 1;
else
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 2;
// track while reading, as we need to track resource usage
m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.buf = GetResID(buffer);
ObjDisp(commandBuffer)
->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
}
}
return true;
}
void WrappedVulkan::vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkDeviceSize size,
VkIndexType indexType)
{
SCOPED_DBG_SINK();
SERIALISE_TIME_CALL(
ObjDisp(commandBuffer)
->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBindIndexBuffer2KHR);
Serialise_vkCmdBindIndexBuffer2KHR(ser, commandBuffer, buffer, offset, size, indexType);
record->AddChunk(scope.Get(&record->cmdInfo->alloc));
record->MarkBufferFrameReferenced(GetRecord(buffer), offset, size, eFrameRef_Read);
}
}
INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool, VkDevice device,
const VkCommandPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *, VkCommandPool *pCommandPool);
@@ -8704,3 +8793,7 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdWriteAccelerationStructuresProperties
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindShadersEXT, VkCommandBuffer commandBuffer,
uint32_t stageCount, const VkShaderStageFlagBits *pStages,
const VkShaderEXT *pShaders);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer commandBuffer,
VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
VkIndexType indexType);
renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp
+8
View File
@@ -3465,6 +3465,14 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
CHECK_PHYS_EXT_FEATURE(rayTracingPositionFetch);
}
END_PHYS_EXT_CHECK();
BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceMaintenance5Features,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
{
CHECK_PHYS_EXT_FEATURE(maintenance5);
m_Maintenance5 = ext->maintenance5 != VK_FALSE;
}
END_PHYS_EXT_CHECK();
}
if(availFeatures.depthClamp)
renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp
+145 -97
View File
@@ -87,6 +87,105 @@ void ClampPhysDevAPIVersion(VkPhysicalDeviceProperties *pProperties, VkPhysicalD
pProperties->apiVersion = VK_API_VERSION_1_3;
}
void WrappedVulkan::PatchImageCreateInfo(VkImageCreateInfo *info, VkFormat *newViewFormatsTempMem)
{
info->usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(IsYUVFormat(info->format))
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(IsCaptureMode(m_State))
{
if(!IsDepthOrStencilFormat(info->format))
{
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
info->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
else
{
info->usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
}
info->flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |=
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
// similarly for the image format list for MSAA textures, add the UINT cast format we will need
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
VkImageFormatListCreateInfo *formatListInfo = (VkImageFormatListCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
if(formatListInfo)
{
uint32_t bs = (uint32_t)GetByteSize(1, 1, 1, info->format, 0);
VkFormat msaaCopyFormat = VK_FORMAT_UNDEFINED;
if(bs == 1)
msaaCopyFormat = VK_FORMAT_R8_UINT;
else if(bs == 2)
msaaCopyFormat = VK_FORMAT_R16_UINT;
else if(bs == 4)
msaaCopyFormat = VK_FORMAT_R32_UINT;
else if(bs == 8)
msaaCopyFormat = VK_FORMAT_R32G32_UINT;
else if(bs == 16)
msaaCopyFormat = VK_FORMAT_R32G32B32A32_UINT;
const VkFormat *oldFmts = formatListInfo->pViewFormats;
formatListInfo->pViewFormats = newViewFormatsTempMem;
bool needAdded = true;
uint32_t i = 0;
for(; i < formatListInfo->viewFormatCount; i++)
{
newViewFormatsTempMem[i] = oldFmts[i];
if(newViewFormatsTempMem[i] == msaaCopyFormat)
needAdded = false;
}
if(needAdded)
{
newViewFormatsTempMem[i] = msaaCopyFormat;
formatListInfo->viewFormatCount++;
}
newViewFormatsTempMem += formatListInfo->viewFormatCount;
}
}
}
void WrappedVulkan::vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures *pFeatures)
{
@@ -332,10 +431,12 @@ void WrappedVulkan::vkGetDeviceBufferMemoryRequirements(VkDevice device,
VkBufferCreateInfo *info = (VkBufferCreateInfo *)unwrappedInfo->pCreateInfo;
// patch the create info the same as we would for vkCreateBuffer
info->usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
info->usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
uint64_t usage = GetBufferUsageFlags(info);
usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
SetBufferUsageFlags(info, usage);
if(IsCaptureMode(m_State) && (info->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT))
if(IsCaptureMode(m_State) && (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT))
info->flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
ObjDisp(device)->GetDeviceBufferMemoryRequirements(Unwrap(device), unwrappedInfo,
@@ -402,100 +503,7 @@ void WrappedVulkan::vkGetDeviceImageMemoryRequirements(VkDevice device,
VkImageCreateInfo *info = (VkImageCreateInfo *)unwrappedInfo->pCreateInfo;
info->usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(IsYUVFormat(info->format))
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
info->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
if(IsCaptureMode(m_State))
{
if(!IsDepthOrStencilFormat(info->format))
{
if(GetDebugManager() && GetShaderCache()->IsBuffer2MSSupported())
info->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
else
{
info->usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
}
info->flags &= ~VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
VkImageStencilUsageCreateInfo *separateStencilUsage =
(VkImageStencilUsageCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
if(separateStencilUsage)
{
separateStencilUsage->stencilUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if(IsCaptureMode(m_State))
{
info->usage |= VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
info->usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
}
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
separateStencilUsage->stencilUsage |=
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
}
// similarly for the image format list for MSAA textures, add the UINT cast format we will need
if(info->samples != VK_SAMPLE_COUNT_1_BIT)
{
VkImageFormatListCreateInfo *formatListInfo = (VkImageFormatListCreateInfo *)FindNextStruct(
info, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
if(formatListInfo)
{
uint32_t bs = (uint32_t)GetByteSize(1, 1, 1, info->format, 0);
VkFormat msaaCopyFormat = VK_FORMAT_UNDEFINED;
if(bs == 1)
msaaCopyFormat = VK_FORMAT_R8_UINT;
else if(bs == 2)
msaaCopyFormat = VK_FORMAT_R16_UINT;
else if(bs == 4)
msaaCopyFormat = VK_FORMAT_R32_UINT;
else if(bs == 8)
msaaCopyFormat = VK_FORMAT_R32G32_UINT;
else if(bs == 16)
msaaCopyFormat = VK_FORMAT_R32G32B32A32_UINT;
const VkFormat *oldFmts = formatListInfo->pViewFormats;
VkFormat *newFmts = (VkFormat *)tempMem;
formatListInfo->pViewFormats = newFmts;
bool needAdded = true;
uint32_t i = 0;
for(; i < formatListInfo->viewFormatCount; i++)
{
newFmts[i] = oldFmts[i];
if(newFmts[i] == msaaCopyFormat)
needAdded = false;
}
if(needAdded)
{
newFmts[i] = msaaCopyFormat;
formatListInfo->viewFormatCount++;
}
}
}
PatchImageCreateInfo(info, (VkFormat *)tempMem);
ObjDisp(device)->GetDeviceImageMemoryRequirements(Unwrap(device), unwrappedInfo,
pMemoryRequirements);
@@ -1276,3 +1284,43 @@ VkDeviceSize WrappedVulkan::vkGetRayTracingShaderGroupStackSizeKHR(
return ObjDisp(device)->GetRayTracingShaderGroupStackSizeKHR(Unwrap(device), Unwrap(pipeline),
group, groupShader);
}
void WrappedVulkan::vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
const VkDeviceImageSubresourceInfo *pInfo,
VkSubresourceLayout2 *pLayout)
{
size_t tempMemSize = GetNextPatchSize(pInfo);
// reserve space for a patched view format list if necessary
if(pInfo->pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT)
{
const VkImageFormatListCreateInfo *formatListInfo =
(const VkImageFormatListCreateInfo *)FindNextStruct(
pInfo->pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
if(formatListInfo)
tempMemSize += sizeof(VkFormat) * (formatListInfo->viewFormatCount + 1);
}
byte *tempMem = GetTempMemory(tempMemSize);
VkDeviceImageSubresourceInfo *unwrappedInfo = UnwrapStructAndChain(m_State, tempMem, pInfo);
PatchImageCreateInfo((VkImageCreateInfo *)unwrappedInfo->pCreateInfo, (VkFormat *)tempMem);
ObjDisp(device)->GetDeviceImageSubresourceLayoutKHR(Unwrap(device), unwrappedInfo, pLayout);
}
void WrappedVulkan::vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
const VkImageSubresource2 *pSubresource,
VkSubresourceLayout2 *pLayout)
{
ObjDisp(device)->GetImageSubresourceLayout2KHR(Unwrap(device), Unwrap(image), pSubresource,
pLayout);
}
void WrappedVulkan::vkGetRenderingAreaGranularityKHR(VkDevice device,
const VkRenderingAreaInfo *pRenderingAreaInfo,
VkExtent2D *pGranularity)
{
ObjDisp(device)->GetRenderingAreaGranularityKHR(Unwrap(device), pRenderingAreaInfo, pGranularity);
}
renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp
+23 -17
View File
@@ -1761,15 +1761,16 @@ bool WrappedVulkan::Serialise_vkCreateBuffer(SerialiserType &ser, VkDevice devic
{
VkBuffer buf = VK_NULL_HANDLE;
VkBufferUsageFlags origusage = CreateInfo.usage;
uint64_t origusage = GetBufferUsageFlags(&CreateInfo);
uint64_t patchedusage = origusage;
// ensure we can always readback from buffers
CreateInfo.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
patchedusage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
// we only need to add TRANSFER_DST_BIT for dedicated buffers, but there's not a reliable way to
// know if a buffer will be dedicated-allocation or not. We assume that TRANSFER_DST is
// effectively free as a usage bit for all sensible implementations so we just add it here.
CreateInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
patchedusage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
SetBufferUsageFlags(&CreateInfo, patchedusage);
// remap the queue family indices
if(CreateInfo.sharingMode == VK_SHARING_MODE_CONCURRENT)
@@ -1793,7 +1794,7 @@ bool WrappedVulkan::Serialise_vkCreateBuffer(SerialiserType &ser, VkDevice devic
APIProps.SparseResources = true;
}
CreateInfo.usage = origusage;
SetBufferUsageFlags(&CreateInfo, origusage);
if(ret != VK_SUCCESS)
{
@@ -1824,28 +1825,30 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo
// if you change any properties here, ensure you also update
// vkGetDeviceBufferMemoryRequirementsKHR
uint64_t adjusted_usage = GetBufferUsageFlags(&adjusted_info);
// TEMP HACK: Until we define a portable fake hardware, need to match the requirements for usage
// on replay, so that the memory requirements are the same
adjusted_info.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
adjusted_usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
// we only need to add TRANSFER_DST_BIT for dedicated buffers, but there's not a reliable way to
// know if a buffer will be dedicated-allocation or not. We assume that TRANSFER_DST is
// effectively free as a usage bit for all sensible implementations so we just add it here.
adjusted_info.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
adjusted_usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
if(IsCaptureMode(m_State))
{
// If we're using this buffer for AS storage we need to enable BDA
if(adjusted_info.usage & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR)
adjusted_info.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
// If we're using this buffer for AS or OMM storage we need to enable BDA
if(adjusted_usage & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR)
adjusted_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
// If we're using this buffer for device addresses, ensure we force on capture replay bit.
// We ensured the physical device can support this feature before whitelisting the extension.
if(adjusted_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
if(adjusted_usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
adjusted_info.flags |= VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
}
SetBufferUsageFlags(&adjusted_info, adjusted_usage);
byte *tempMem = GetTempMemory(GetNextPatchSize(adjusted_info.pNext));
UnwrapNextChain(m_State, "VkBufferCreateInfo", tempMem, (VkBaseInStructure *)&adjusted_info);
@@ -1873,14 +1876,16 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo
VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pBuffer);
record->memSize = serialisedCreateInfo.size;
uint64_t serialisedUsage = GetBufferUsageFlags(&serialisedCreateInfo);
// If we're using this buffer for AS storage we need to enable BDA
if(serialisedCreateInfo.usage & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR)
serialisedCreateInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
if(serialisedUsage & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR)
serialisedUsage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
SetBufferUsageFlags(&serialisedCreateInfo, serialisedUsage);
// if we're using VK_[KHR|EXT]_buffer_device_address, we fetch the device address that's been
// allocated and insert it into the next chain and patch the flags so that it replays
// naturally.
if((serialisedCreateInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0)
if((serialisedUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0)
{
VkBufferDeviceAddressInfo getInfo = {
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
@@ -1955,8 +1960,9 @@ VkResult WrappedVulkan::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo
record->AddChunk(chunk);
record->storable = (pCreateInfo->usage & (VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) != 0;
record->storable =
(GetBufferUsageFlags(pCreateInfo) &
(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) != 0;
bool isSparse = (pCreateInfo->flags & (VK_BUFFER_CREATE_SPARSE_BINDING_BIT |
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT)) != 0;
renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp
+34 -31
View File
@@ -143,7 +143,7 @@ VkComputePipelineCreateInfo *WrappedVulkan::UnwrapInfos(CaptureState state,
unwrapped[i] = info[i];
unwrapped[i].stage.module = Unwrap(unwrapped[i].stage.module);
unwrapped[i].layout = Unwrap(unwrapped[i].layout);
if(unwrapped[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&unwrapped[i]) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
unwrapped[i].basePipelineHandle = Unwrap(unwrapped[i].basePipelineHandle);
}
@@ -184,7 +184,7 @@ VkGraphicsPipelineCreateInfo *WrappedVulkan::UnwrapInfos(CaptureState state,
unwrappedInfos[i].pStages = unwrappedStages;
unwrappedInfos[i].layout = Unwrap(unwrappedInfos[i].layout);
unwrappedInfos[i].renderPass = Unwrap(unwrappedInfos[i].renderPass);
if(unwrappedInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&unwrappedInfos[i]) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
unwrappedInfos[i].basePipelineHandle = Unwrap(unwrappedInfos[i].basePipelineHandle);
UnwrapNextChain(state, "VkGraphicsPipelineCreateInfo", tempMem,
@@ -727,25 +727,27 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
VkPipeline pipe = VK_NULL_HANDLE;
VkRenderPass origRP = CreateInfo.renderPass;
uint64_t createFlags = GetPipelineCreateFlags(&CreateInfo);
// if we have pipeline executable properties, capture the data
if(GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
{
CreateInfo.flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
createFlags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
}
// don't fail when a compile is required because we don't currently replay caches so this will
// always happen. This still allows application to use this flag at runtime where it will be
// valid
CreateInfo.flags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
createFlags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
// disable pipeline derivatives, because I don't think any driver actually uses them and it
// would require a job-wait for the parent
CreateInfo.flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
createFlags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
CreateInfo.basePipelineHandle = VK_NULL_HANDLE;
CreateInfo.basePipelineIndex = -1;
SetPipelineCreateFlags(&CreateInfo, createFlags);
// we steal the serialised create info here so we can pass it to jobs without its contents and
// all of the allocated structures and arrays being deserialised. We add a job which waits on
// the compiles then deserialises this manually.
@@ -851,7 +853,7 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
DerivedResource(device, Pipeline);
if(pipelineCache != VK_NULL_HANDLE)
DerivedResource(pipelineCache, Pipeline);
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&OrigCreateInfo) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
DerivedResource(OrigCreateInfo.basePipelineHandle, Pipeline);
@@ -961,7 +963,7 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines(VkDevice device, VkPipelineCac
VkGraphicsPipelineCreateInfo modifiedCreateInfo;
const VkGraphicsPipelineCreateInfo *createInfo = &pCreateInfos[i];
if(createInfo->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(createInfo) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
// since we serialise one by one, we need to fixup basePipelineIndex
if(createInfo->basePipelineIndex != -1 && createInfo->basePipelineIndex < (int)i)
@@ -984,7 +986,7 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines(VkDevice device, VkPipelineCac
VkResourceRecord *record = GetResourceManager()->AddResourceRecord(pPipelines[i]);
record->AddChunk(chunk);
if(pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&pCreateInfos[i]) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE)
{
@@ -1071,25 +1073,27 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe
if(IsReplayingAndReading())
{
VkPipeline pipe = VK_NULL_HANDLE;
uint64_t createFlags = GetPipelineCreateFlags(&CreateInfo);
// if we have pipeline executable properties, capture the data
if(GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
{
CreateInfo.flags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
createFlags |= (VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR |
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR);
}
// don't fail when a compile is required because we don't currently replay caches so this will
// always happen. This still allows application to use this flag at runtime where it will be
// valid
CreateInfo.flags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
createFlags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
// disable pipeline derivatives, because I don't think any driver actually uses them and it
// would require a job-wait for the parent
CreateInfo.flags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
createFlags &= ~VK_PIPELINE_CREATE_DERIVATIVE_BIT;
CreateInfo.basePipelineHandle = VK_NULL_HANDLE;
CreateInfo.basePipelineIndex = -1;
SetPipelineCreateFlags(&CreateInfo, createFlags);
// we steal the serialised create info here so we can pass it to jobs without its contents and
// all of the allocated structures and arrays being deserialised. We add a job which waits on
// the compiles then deserialises this manually.
@@ -1171,7 +1175,7 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe
DerivedResource(device, Pipeline);
if(pipelineCache != VK_NULL_HANDLE)
DerivedResource(pipelineCache, Pipeline);
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&OrigCreateInfo) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
DerivedResource(OrigCreateInfo.basePipelineHandle, Pipeline);
@@ -1211,7 +1215,7 @@ VkResult WrappedVulkan::vkCreateComputePipelines(VkDevice device, VkPipelineCach
VkComputePipelineCreateInfo modifiedCreateInfo;
const VkComputePipelineCreateInfo *createInfo = &pCreateInfos[i];
if(createInfo->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(createInfo) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
// since we serialise one by one, we need to fixup basePipelineIndex
if(createInfo->basePipelineIndex != -1 && createInfo->basePipelineIndex < (int)i)
@@ -1240,7 +1244,7 @@ VkResult WrappedVulkan::vkCreateComputePipelines(VkDevice device, VkPipelineCach
record->AddParent(cacherecord);
}
if(pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(pCreateInfos) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE)
{
@@ -1356,7 +1360,9 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
// don't fail when a compile is required because we don't currently replay caches so this will
// always happen. This still allows application to use this flag at runtime where it will be
// valid
CreateInfo.flags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
uint64_t createFlags = GetPipelineCreateFlags(&CreateInfo);
createFlags &= ~VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
SetPipelineCreateFlags(&CreateInfo, createFlags);
// we steal the serialised create info and handle buffer here so we can pass it to jobs without
// its contents and all of the allocated structures and arrays being deserialised. We add a job
@@ -1380,7 +1386,7 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
DerivedResource(device, Pipeline);
if(pipelineCache != VK_NULL_HANDLE)
DerivedResource(pipelineCache, Pipeline);
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&OrigCreateInfo) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
DerivedResource(OrigCreateInfo.basePipelineHandle, Pipeline);
@@ -1463,13 +1469,9 @@ VkResult WrappedVulkan::vkCreateRayTracingPipelinesKHR(
pPipelines[i] = VK_NULL_HANDLE;
// Patch in capture/replay creation flags
VkPipelineCreateFlags2CreateInfo *flagsInfo = (VkPipelineCreateFlags2CreateInfo *)FindNextStruct(
&unwrappedCreateInfos[i], VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
if(flagsInfo)
flagsInfo->flags |= VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR;
else
unwrappedCreateInfos[i].flags |=
VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR;
uint64_t createFlags = GetPipelineCreateFlags(&unwrappedCreateInfos[i]);
createFlags |= VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR;
SetPipelineCreateFlags(&unwrappedCreateInfos[i], createFlags);
}
// deferred operations are currently not wrapped
@@ -1496,10 +1498,11 @@ VkResult WrappedVulkan::vkCreateRayTracingPipelinesKHR(
CACHE_THREAD_SERIALISER();
VkRayTracingPipelineCreateInfoKHR modifiedCreateInfo = pCreateInfos[i];
modifiedCreateInfo.flags |=
VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR;
uint64_t createFlags = GetPipelineCreateFlags(&modifiedCreateInfo);
createFlags |= VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR;
SetPipelineCreateFlags(&modifiedCreateInfo, createFlags);
if(pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(createFlags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
// since we serialise one by one, we need to fixup basePipelineIndex
if(pCreateInfos[i].basePipelineIndex != -1 && pCreateInfos[i].basePipelineIndex < (int)i)
@@ -1520,7 +1523,7 @@ VkResult WrappedVulkan::vkCreateRayTracingPipelinesKHR(
VkResourceRecord *record = GetResourceManager()->AddResourceRecord(pPipelines[i]);
record->AddChunk(chunk);
if(pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
if(GetPipelineCreateFlags(&pCreateInfos[i]) & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
{
if(pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE)
{
renderdoc/replay/renderdoc_serialise.inl
+4 -3
View File
@@ -1954,9 +1954,10 @@ void DoSerialise(SerialiserType &ser, VKPipe::IndexBuffer &el)
{
SERIALISE_MEMBER(resourceId);
SERIALISE_MEMBER(byteOffset);
SERIALISE_MEMBER(byteSize);
SERIALISE_MEMBER(byteStride);
SIZE_CHECK(24);
SIZE_CHECK(32);
}
template <typename SerialiserType>
@@ -1966,7 +1967,7 @@ void DoSerialise(SerialiserType &ser, VKPipe::InputAssembly &el)
SERIALISE_MEMBER(indexBuffer);
SERIALISE_MEMBER(topology);
SIZE_CHECK(40);
SIZE_CHECK(48);
}
template <typename SerialiserType>
@@ -2295,7 +2296,7 @@ void DoSerialise(SerialiserType &ser, VKPipe::State &el)
SERIALISE_MEMBER(conditionalRendering);
SIZE_CHECK(1872);
SIZE_CHECK(1880);
}
#pragma endregion Vulkan pipeline state