From d00556dbb527fefdfac63789ee2a12bceac20bab Mon Sep 17 00:00:00 2001 From: baldurk Date: Fri, 22 Oct 2021 16:22:42 +0100 Subject: [PATCH] Support VK_EXT_dynamic_state2 & VK_EXT_vertex_input_dynamic_state --- .../VulkanPipelineStateViewer.cpp | 31 +- renderdoc/api/replay/vk_pipestate.h | 2 + renderdoc/driver/vulkan/extension_support.md | 4 +- renderdoc/driver/vulkan/vk_common.h | 14 + renderdoc/driver/vulkan/vk_core.cpp | 20 ++ renderdoc/driver/vulkan/vk_core.h | 26 ++ renderdoc/driver/vulkan/vk_hookset_defs.h | 29 +- renderdoc/driver/vulkan/vk_info.h | 4 +- renderdoc/driver/vulkan/vk_next_chains.cpp | 12 +- renderdoc/driver/vulkan/vk_overlay.cpp | 28 +- renderdoc/driver/vulkan/vk_replay.cpp | 10 +- renderdoc/driver/vulkan/vk_serialise.cpp | 95 +++++- renderdoc/driver/vulkan/vk_shaderdebug.cpp | 2 +- renderdoc/driver/vulkan/vk_state.cpp | 21 ++ renderdoc/driver/vulkan/vk_state.h | 11 + renderdoc/driver/vulkan/vk_stringise.cpp | 8 +- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 154 ++++++++- .../vulkan/wrappers/vk_device_funcs.cpp | 20 ++ .../vulkan/wrappers/vk_dynamic_funcs.cpp | 316 ++++++++++++++++++ renderdoc/replay/renderdoc_serialise.inl | 5 +- 20 files changed, 777 insertions(+), 35 deletions(-) diff --git a/qrenderdoc/Windows/PipelineState/VulkanPipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/VulkanPipelineStateViewer.cpp index eedd691c6..259a3a665 100644 --- a/qrenderdoc/Windows/PipelineState/VulkanPipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/VulkanPipelineStateViewer.cpp @@ -2446,9 +2446,24 @@ void VulkanPipelineStateViewer::setState() ui->cullMode->setText(ToQStr(state.rasterizer.cullMode)); ui->frontCCW->setPixmap(state.rasterizer.frontCCW ? tick : cross); - ui->depthBias->setText(Formatter::Format(state.rasterizer.depthBias)); - ui->depthBiasClamp->setText(Formatter::Format(state.rasterizer.depthBiasClamp)); - ui->slopeScaledBias->setText(Formatter::Format(state.rasterizer.slopeScaledDepthBias)); + if(state.rasterizer.depthBiasEnable) + { + ui->depthBias->setText(Formatter::Format(state.rasterizer.depthBias)); + ui->depthBiasClamp->setText(Formatter::Format(state.rasterizer.depthBiasClamp)); + ui->slopeScaledBias->setText(Formatter::Format(state.rasterizer.slopeScaledDepthBias)); + ui->depthBias->setPixmap(QPixmap()); + ui->depthBiasClamp->setPixmap(QPixmap()); + ui->slopeScaledBias->setPixmap(QPixmap()); + } + else + { + ui->depthBias->setText(QString()); + ui->depthBiasClamp->setText(QString()); + ui->slopeScaledBias->setText(QString()); + ui->depthBias->setPixmap(cross); + ui->depthBiasClamp->setPixmap(cross); + ui->slopeScaledBias->setPixmap(cross); + } ui->depthClamp->setPixmap(state.rasterizer.depthClampEnable ? tick : cross); ui->depthClip->setPixmap(state.rasterizer.depthClipEnable ? tick : cross); @@ -3733,9 +3748,13 @@ void VulkanPipelineStateViewer::exportHTML(QXmlStreamWriter &xml, const VKPipe:: xml.writeEndElement(); m_Common.exportHTMLTable( - xml, {tr("Depth Bias"), tr("Depth Bias Clamp"), tr("Slope Scaled Bias"), tr("Line Width")}, - {Formatter::Format(rs.depthBias), Formatter::Format(rs.depthBiasClamp), - Formatter::Format(rs.slopeScaledDepthBias), Formatter::Format(rs.lineWidth)}); + xml, {tr("Depth Bias Enable"), tr("Depth Bias"), tr("Depth Bias Clamp"), + tr("Slope Scaled Bias"), tr("Line Width")}, + { + rs.depthBiasEnable ? tr("Yes") : tr("No"), Formatter::Format(rs.depthBias), + Formatter::Format(rs.depthBiasClamp), Formatter::Format(rs.slopeScaledDepthBias), + Formatter::Format(rs.lineWidth), + }); } const VKPipe::MultiSample &msaa = m_Ctx.CurVulkanPipelineState()->multisample; diff --git a/renderdoc/api/replay/vk_pipestate.h b/renderdoc/api/replay/vk_pipestate.h index 7206c26b1..18c538474 100644 --- a/renderdoc/api/replay/vk_pipestate.h +++ b/renderdoc/api/replay/vk_pipestate.h @@ -805,6 +805,8 @@ See :data:`conservativeRasterizationMode` )"); float extraPrimitiveOverestimationSize = 0.0f; + DOCUMENT("Whether depth biasing is enabled."); + bool depthBiasEnable = false; DOCUMENT("The fixed depth bias value to apply to z-values."); float depthBias = 0.0f; DOCUMENT(R"(The clamp value for calculated depth bias from :data:`depthBias` and diff --git a/renderdoc/driver/vulkan/extension_support.md b/renderdoc/driver/vulkan/extension_support.md index 9b9b42809..b030945ef 100644 --- a/renderdoc/driver/vulkan/extension_support.md +++ b/renderdoc/driver/vulkan/extension_support.md @@ -41,6 +41,7 @@ Maintainers can update this file by updating vk.xml in this folder and running ` * `VK_EXT_display_control` * `VK_EXT_display_surface_counter` * `VK_EXT_extended_dynamic_state` +* `VK_EXT_extended_dynamic_state2` * `VK_EXT_external_memory_dma_buf` * `VK_EXT_filter_cubic` * `VK_EXT_fragment_density_map` @@ -89,6 +90,7 @@ Maintainers can update this file by updating vk.xml in this folder and running ` * `VK_EXT_validation_features` * `VK_EXT_validation_flags` * `VK_EXT_vertex_attribute_divisor` +* `VK_EXT_vertex_input_dynamic_state` * `VK_EXT_ycbcr_2plane_444_formats` * `VK_EXT_ycbcr_image_arrays` * `VK_GGP_frame_token` @@ -223,7 +225,6 @@ Ray tracing extensions are now standard and will likely be supported at some poi * `VK_EXT_blend_operation_advanced` * `VK_EXT_border_color_swizzle` * `VK_EXT_device_memory_report` -* `VK_EXT_extended_dynamic_state2` * `VK_EXT_external_memory_host` * `VK_EXT_image_drm_format_modifier` * `VK_EXT_multi_draw` @@ -232,7 +233,6 @@ Ray tracing extensions are now standard and will likely be supported at some poi * `VK_EXT_primitive_topology_list_restart` * `VK_EXT_provoking_vertex` * `VK_EXT_texture_compression_astc_hdr` -* `VK_EXT_vertex_input_dynamic_state` ## Platform/IHV Extensions diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index dc17bafdd..319c8bec4 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -716,6 +716,12 @@ enum class VulkanChunk : uint32_t vkQueueSubmit2KHR, vkCmdWriteBufferMarker2AMD, vkCmdSetColorWriteEnableEXT, + vkCmdSetDepthBiasEnableEXT, + vkCmdSetLogicOpEXT, + vkCmdSetPatchControlPointsEXT, + vkCmdSetPrimitiveRestartEnableEXT, + vkCmdSetRasterizerDiscardEnableEXT, + vkCmdSetVertexInputEXT, Max, }; @@ -931,6 +937,7 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceDescriptorIndexingProperties) DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceDiscardRectanglePropertiesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceDriverProperties); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); +DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalBufferInfo); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalFenceInfo); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceExternalImageFormatInfo); @@ -1017,6 +1024,7 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceUniformBufferStandardLayoutFeatures); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVariablePointerFeatures); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); +DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan11Features); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan11Properties); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan12Features); @@ -1113,6 +1121,8 @@ DECLARE_REFLECTION_STRUCT(VkTimelineSemaphoreSubmitInfo); DECLARE_REFLECTION_STRUCT(VkValidationCacheCreateInfoEXT); DECLARE_REFLECTION_STRUCT(VkValidationFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkValidationFlagsEXT); +DECLARE_REFLECTION_STRUCT(VkVertexInputAttributeDescription2EXT); +DECLARE_REFLECTION_STRUCT(VkVertexInputBindingDescription2EXT); DECLARE_REFLECTION_STRUCT(VkWriteDescriptorSet); DECLARE_REFLECTION_STRUCT(VkWriteDescriptorSetInlineUniformBlockEXT); @@ -1278,6 +1288,7 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceDescriptorIndexingProperties) DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceDiscardRectanglePropertiesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceDriverProperties); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); +DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalBufferInfo); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalFenceInfo); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceExternalImageFormatInfo); @@ -1364,6 +1375,7 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeatures); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVariablePointerFeatures); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); +DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan11Features); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan11Properties); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan12Features); @@ -1457,6 +1469,8 @@ DECLARE_DESERIALISE_TYPE(VkTimelineSemaphoreSubmitInfo); DECLARE_DESERIALISE_TYPE(VkValidationCacheCreateInfoEXT); DECLARE_DESERIALISE_TYPE(VkValidationFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkValidationFlagsEXT); +DECLARE_DESERIALISE_TYPE(VkVertexInputAttributeDescription2EXT); +DECLARE_DESERIALISE_TYPE(VkVertexInputBindingDescription2EXT); DECLARE_DESERIALISE_TYPE(VkWriteDescriptorSet); DECLARE_DESERIALISE_TYPE(VkWriteDescriptorSetInlineUniformBlockEXT); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index dd11fd8f6..99dac9263 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -924,6 +924,9 @@ static const VkExtensionProperties supportedExtensions[] = { { VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION, }, + { + VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME, VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION, + }, { VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME, VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION, }, @@ -1076,6 +1079,10 @@ static const VkExtensionProperties supportedExtensions[] = { { VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION, }, + { + VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME, + VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION, + }, { VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME, VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION, }, @@ -3487,6 +3494,19 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) case VulkanChunk::vkCmdSetColorWriteEnableEXT: return Serialise_vkCmdSetColorWriteEnableEXT(ser, VK_NULL_HANDLE, 0, NULL); + case VulkanChunk::vkCmdSetDepthBiasEnableEXT: + return Serialise_vkCmdSetDepthBiasEnableEXT(ser, VK_NULL_HANDLE, VK_FALSE); + case VulkanChunk::vkCmdSetLogicOpEXT: + return Serialise_vkCmdSetLogicOpEXT(ser, VK_NULL_HANDLE, VK_LOGIC_OP_MAX_ENUM); + case VulkanChunk::vkCmdSetPatchControlPointsEXT: + return Serialise_vkCmdSetPatchControlPointsEXT(ser, VK_NULL_HANDLE, 0); + case VulkanChunk::vkCmdSetPrimitiveRestartEnableEXT: + return Serialise_vkCmdSetPrimitiveRestartEnableEXT(ser, VK_NULL_HANDLE, VK_FALSE); + case VulkanChunk::vkCmdSetRasterizerDiscardEnableEXT: + return Serialise_vkCmdSetRasterizerDiscardEnableEXT(ser, VK_NULL_HANDLE, VK_FALSE); + case VulkanChunk::vkCmdSetVertexInputEXT: + return Serialise_vkCmdSetVertexInputEXT(ser, VK_NULL_HANDLE, 0, NULL, 0, NULL); + // chunks that are reserved but not yet serialised case VulkanChunk::vkResetCommandPool: case VulkanChunk::vkCreateDepthTargetView: diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index fbb2b7fa3..545bf1432 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -407,7 +407,9 @@ private: bool m_SeparateDepthStencil = false; bool m_NULLDescriptorsAllowed = false; bool m_ExtendedDynState = false; + bool m_ExtendedDynState2 = false; bool m_DynColorWrite = false; + bool m_DynVertexInput = false; PFN_vkSetDeviceLoaderData m_SetDeviceLoaderData; @@ -1123,7 +1125,9 @@ public: bool SeparateDepthStencil() const { return m_SeparateDepthStencil; } bool NULLDescriptorsAllowed() const { return m_NULLDescriptorsAllowed; } bool ExtendedDynamicState() const { return m_ExtendedDynState; } + bool ExtendedDynamicState2() const { return m_ExtendedDynState2; } bool DynamicColorWrite() const { return m_DynColorWrite; } + bool DynamicVertexInput() const { return m_DynVertexInput; } VulkanRenderState &GetRenderState() { return m_RenderState; } void SetActionCB(VulkanActionCallback *cb) { m_ActionCallback = cb; } void SetSubmitChain(void *submitChain) { m_SubmitChain = submitChain; } @@ -2480,4 +2484,26 @@ public: IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetColorWriteEnableEXT, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables); + + // VK_EXT_extended_dynamic_state2 + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetDepthBiasEnableEXT, VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetLogicOpEXT, VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetPatchControlPointsEXT, VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetPrimitiveRestartEnableEXT, + VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetRasterizerDiscardEnableEXT, + VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); + + // VK_EXT_vertex_input_dynamic_state + + IMPLEMENT_FUNCTION_SERIALISED( + void, vkCmdSetVertexInputEXT, VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions); }; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 5734f4cfd..ae5b8169f 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -530,7 +530,9 @@ DeclExt(KHR_synchronization2); \ DeclExt(KHR_present_wait); \ DeclExt(KHR_maintenance4); \ - DeclExt(EXT_color_write_enable); + DeclExt(EXT_color_write_enable); \ + DeclExt(EXT_extended_dynamic_state2); \ + DeclExt(EXT_vertex_input_dynamic_state); // for simplicity and since the check itself is platform agnostic, // these aren't protected in platform defines @@ -633,7 +635,9 @@ CheckExt(KHR_synchronization2, VKXX); \ CheckExt(KHR_present_wait, VKXX); \ CheckExt(KHR_maintenance4, VKXX); \ - CheckExt(EXT_color_write_enable, VKXX); + CheckExt(EXT_color_write_enable, VKXX); \ + CheckExt(EXT_extended_dynamic_state2, VKXX); \ + CheckExt(EXT_vertex_input_dynamic_state, VKXX); #define HookInitVulkanInstanceExts_PhysDev() \ HookInitExtension(KHR_surface, GetPhysicalDeviceSurfaceSupportKHR); \ @@ -874,12 +878,18 @@ HookInitExtension(KHR_synchronization2, CmdWriteTimestamp2KHR); \ HookInitExtension(KHR_synchronization2, QueueSubmit2KHR); \ HookInitExtension(KHR_synchronization2 &&AMD_buffer_marker, CmdWriteBufferMarker2AMD); \ + /* No GetQueueCheckpointData2NV without VK_NV_device_diagnostic_checkpoints */ \ HookInitExtension(KHR_present_wait, WaitForPresentKHR); \ HookInitExtension(KHR_maintenance4, GetDeviceBufferMemoryRequirementsKHR); \ HookInitExtension(KHR_maintenance4, GetDeviceImageMemoryRequirementsKHR); \ HookInitExtension(KHR_maintenance4, GetDeviceImageSparseMemoryRequirementsKHR); \ HookInitExtension(EXT_color_write_enable, CmdSetColorWriteEnableEXT); \ - /* No GetQueueCheckpointData2NV without VK_NV_device_diagnostic_checkpoints */ \ + HookInitExtension(EXT_extended_dynamic_state2, CmdSetDepthBiasEnableEXT); \ + HookInitExtension(EXT_extended_dynamic_state2, CmdSetLogicOpEXT); \ + HookInitExtension(EXT_extended_dynamic_state2, CmdSetPatchControlPointsEXT); \ + HookInitExtension(EXT_extended_dynamic_state2, CmdSetPrimitiveRestartEnableEXT); \ + HookInitExtension(EXT_extended_dynamic_state2, CmdSetRasterizerDiscardEnableEXT); \ + HookInitExtension(EXT_vertex_input_dynamic_state, CmdSetVertexInputEXT); \ HookInitExtension_Device_Win32(); \ HookInitExtension_Device_Linux(); \ HookInitExtension_Device_GGP(); \ @@ -1577,6 +1587,19 @@ pSparseMemoryRequirements); \ HookDefine3(void, vkCmdSetColorWriteEnableEXT, VkCommandBuffer, commandBuffer, uint32_t, \ attachmentCount, const VkBool32 *, pColorWriteEnables); \ + HookDefine2(void, vkCmdSetDepthBiasEnableEXT, VkCommandBuffer, commandBuffer, VkBool32, \ + depthBiasEnable); \ + HookDefine2(void, vkCmdSetLogicOpEXT, VkCommandBuffer, commandBuffer, VkLogicOp, logicOp); \ + HookDefine2(void, vkCmdSetPatchControlPointsEXT, VkCommandBuffer, commandBuffer, uint32_t, \ + patchControlPoints); \ + HookDefine2(void, vkCmdSetPrimitiveRestartEnableEXT, VkCommandBuffer, commandBuffer, VkBool32, \ + primitiveRestartEnable); \ + HookDefine2(void, vkCmdSetRasterizerDiscardEnableEXT, VkCommandBuffer, commandBuffer, VkBool32, \ + rasterizerDiscardEnable); \ + HookDefine5(void, vkCmdSetVertexInputEXT, VkCommandBuffer, commandBuffer, uint32_t, \ + vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *, \ + pVertexBindingDescriptions, uint32_t, vertexAttributeDescriptionCount, \ + const VkVertexInputAttributeDescription2EXT *, pVertexAttributeDescriptions); \ HookDefine_Win32(); \ HookDefine_Linux(); \ HookDefine_GGP(); \ diff --git a/renderdoc/driver/vulkan/vk_info.h b/renderdoc/driver/vulkan/vk_info.h index 8cb415d6c..f5821eb68 100644 --- a/renderdoc/driver/vulkan/vk_info.h +++ b/renderdoc/driver/vulkan/vk_info.h @@ -279,7 +279,7 @@ struct VulkanCreationInfo Shader shaders[6]; // VkPipelineVertexInputStateCreateInfo - struct Binding + struct VertBinding { uint32_t vbufferBinding; uint32_t bytestride; @@ -288,7 +288,7 @@ struct VulkanCreationInfo // VkVertexInputBindingDivisorDescriptionEXT uint32_t instanceDivisor; }; - rdcarray vertexBindings; + rdcarray vertexBindings; struct Attribute { diff --git a/renderdoc/driver/vulkan/vk_next_chains.cpp b/renderdoc/driver/vulkan/vk_next_chains.cpp index 11182c480..dc4df130d 100644 --- a/renderdoc/driver/vulkan/vk_next_chains.cpp +++ b/renderdoc/driver/vulkan/vk_next_chains.cpp @@ -231,6 +231,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, VkPhysicalDeviceDriverProperties); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, \ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, \ + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, \ VkPhysicalDeviceExternalBufferInfo); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, \ @@ -393,6 +395,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, \ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, \ + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, \ VkPhysicalDeviceUniformBufferStandardLayoutFeatures); \ COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, \ @@ -515,6 +519,10 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, COPY_STRUCT(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VkTimelineSemaphoreSubmitInfo); \ COPY_STRUCT(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, VkValidationCacheCreateInfoEXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, VkValidationFeaturesEXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, \ + VkVertexInputAttributeDescription2EXT); \ + COPY_STRUCT(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, \ + VkVertexInputBindingDescription2EXT); \ COPY_STRUCT(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, \ VkWriteDescriptorSetInlineUniformBlockEXT); \ COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, \ @@ -740,7 +748,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: \ - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: \ @@ -776,7 +783,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: \ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: \ - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: \ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: \ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: \ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: \ @@ -807,8 +813,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct, case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: \ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: \ case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: \ - case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: \ - case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: \ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: \ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: diff --git a/renderdoc/driver/vulkan/vk_overlay.cpp b/renderdoc/driver/vulkan/vk_overlay.cpp index 7d3b965b0..7a8c66065 100644 --- a/renderdoc/driver/vulkan/vk_overlay.cpp +++ b/renderdoc/driver/vulkan/vk_overlay.cpp @@ -2576,9 +2576,11 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D // remove any dynamic states we don't want for(uint32_t i = 0; i < dynamicStateCount;) { - // we are controlling the vertex binding so we don't need the stride to be dynamic. + // we are controlling the vertex binding so we don't need the stride or input to be + // dynamic. // Similarly we're controlling the topology so that doesn't need to be dynamic if(dynamicStateList[i] == VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT || + dynamicStateList[i] == VK_DYNAMIC_STATE_VERTEX_INPUT_EXT || dynamicStateList[i] == VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT) { // swap with the last item if this isn't the last one @@ -2771,6 +2773,30 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D vt->CmdSetColorWriteEnableEXT(Unwrap(cmd), (uint32_t)state.colorWriteEnable.size(), state.colorWriteEnable.data()); } + else if(d == VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT) + { + vt->CmdSetDepthBiasEnableEXT(Unwrap(cmd), state.depthBiasEnable); + } + else if(d == VK_DYNAMIC_STATE_LOGIC_OP_EXT) + { + vt->CmdSetLogicOpEXT(Unwrap(cmd), state.logicOp); + } + else if(d == VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT) + { + vt->CmdSetPatchControlPointsEXT(Unwrap(cmd), state.patchControlPoints); + } + else if(d == VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT) + { + vt->CmdSetPrimitiveRestartEnableEXT(Unwrap(cmd), state.primRestartEnable); + } + else if(d == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + { + vt->CmdSetRasterizerDiscardEnableEXT(Unwrap(cmd), state.rastDiscardEnable); + } + else if(d == VK_DYNAMIC_STATE_VERTEX_INPUT_EXT) + { + RDCERR("Vertex input dynamic state found, should have been stripped"); + } } if(fmt.indexByteStride) diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 7a6154ad8..e81bfac26 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -1171,8 +1171,9 @@ void VulkanReplay::SavePipelineState(uint32_t eventId) ret.inputAssembly.indexBuffer.resourceId = rm->GetOriginalID(state.ibuffer.buf); ret.inputAssembly.indexBuffer.byteOffset = state.ibuffer.offs; ret.inputAssembly.indexBuffer.byteStride = state.ibuffer.bytewidth; - ret.inputAssembly.primitiveRestartEnable = p.primitiveRestartEnable; - ret.inputAssembly.topology = MakePrimitiveTopology(state.primitiveTopology, p.patchControlPoints); + ret.inputAssembly.primitiveRestartEnable = state.primRestartEnable != VK_FALSE; + ret.inputAssembly.topology = + MakePrimitiveTopology(state.primitiveTopology, state.patchControlPoints); // Vertex Input ret.vertexInput.attributes.resize(p.vertexAttrs.size()); @@ -1338,7 +1339,7 @@ void VulkanReplay::SavePipelineState(uint32_t eventId) // Rasterizer ret.rasterizer.depthClampEnable = p.depthClampEnable; ret.rasterizer.depthClipEnable = p.depthClipEnable; - ret.rasterizer.rasterizerDiscardEnable = p.rasterizerDiscardEnable; + ret.rasterizer.rasterizerDiscardEnable = state.rastDiscardEnable != VK_FALSE; ret.rasterizer.frontCCW = state.frontFace == VK_FRONT_FACE_COUNTER_CLOCKWISE; ret.rasterizer.conservativeRasterization = ConservativeRaster::Disabled; @@ -1402,6 +1403,7 @@ void VulkanReplay::SavePipelineState(uint32_t eventId) break; } + ret.rasterizer.depthBiasEnable = state.depthBiasEnable != VK_FALSE; ret.rasterizer.depthBias = state.bias.depth; ret.rasterizer.depthBiasClamp = state.bias.biasclamp; ret.rasterizer.slopeScaledDepthBias = state.bias.slope; @@ -1437,7 +1439,7 @@ void VulkanReplay::SavePipelineState(uint32_t eventId) // due to shared structs, this is slightly duplicated - Vulkan doesn't have separate states // for logic operations ret.colorBlend.blends[i].logicOperationEnabled = p.logicOpEnable; - ret.colorBlend.blends[i].logicOperation = MakeLogicOp(p.logicOp); + ret.colorBlend.blends[i].logicOperation = MakeLogicOp(state.logicOp); ret.colorBlend.blends[i].colorBlend.source = MakeBlendMultiplier(p.attachments[i].blend.Source); ret.colorBlend.blends[i].colorBlend.destination = diff --git a/renderdoc/driver/vulkan/vk_serialise.cpp b/renderdoc/driver/vulkan/vk_serialise.cpp index 9fb73e253..48b65ea8a 100644 --- a/renderdoc/driver/vulkan/vk_serialise.cpp +++ b/renderdoc/driver/vulkan/vk_serialise.cpp @@ -639,6 +639,10 @@ SERIALISE_VK_HANDLES(); PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, \ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT) \ \ + /* VK_EXT_extended_dynamic_state2 */ \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, \ + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT) \ + \ /* VK_EXT_filter_cubic */ \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, \ VkPhysicalDeviceImageViewImageFormatInfoEXT) \ @@ -828,6 +832,14 @@ SERIALISE_VK_HANDLES(); PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, \ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT) \ \ + /* VK_EXT_vertex_input_dynamic_state */ \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, \ + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, \ + VkVertexInputBindingDescription2EXT) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, \ + VkVertexInputAttributeDescription2EXT) \ + \ /* VK_EXT_ycbcr_2plane_444_formats */ \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, \ VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT) \ @@ -1267,9 +1279,6 @@ SERIALISE_VK_HANDLES(); PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT) \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT) \ \ - /* VK_EXT_extended_dynamic_state2 */ \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT) \ - \ /* VK_EXT_external_memory_host */ \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT) \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT) \ @@ -1307,11 +1316,6 @@ SERIALISE_VK_HANDLES(); /* VK_EXT_texture_compression_astc_hdr */ \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT) \ \ - /* VK_EXT_vertex_input_dynamic_state */ \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT) \ - \ /* VK_HUAWEI_invocation_mask */ \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI) \ \ @@ -4891,6 +4895,59 @@ void Deserialise(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &el) DeserialiseNext(el.pNext); } +template +void DoSerialise(SerialiserType &ser, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(vertexInputDynamicState); +} + +template <> +void Deserialise(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkVertexInputBindingDescription2EXT &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(binding); + SERIALISE_MEMBER(stride); + SERIALISE_MEMBER(inputRate); + SERIALISE_MEMBER(divisor); +} + +template <> +void Deserialise(const VkVertexInputBindingDescription2EXT &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkVertexInputAttributeDescription2EXT &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(location); + SERIALISE_MEMBER(binding); + SERIALISE_MEMBER(format); + SERIALISE_MEMBER(offset); +} + +template <> +void Deserialise(const VkVertexInputAttributeDescription2EXT &el) +{ + DeserialiseNext(el.pNext); +} + template void DoSerialise(SerialiserType &ser, VkPhysicalDevice8BitStorageFeatures &el) { @@ -5243,6 +5300,24 @@ void Deserialise(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &el) DeserialiseNext(el.pNext); } +template +void DoSerialise(SerialiserType &ser, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(extendedDynamicState2); + SERIALISE_MEMBER(extendedDynamicState2LogicOp); + SERIALISE_MEMBER(extendedDynamicState2PatchControlPoints); +} + +template <> +void Deserialise(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &el) +{ + DeserialiseNext(el.pNext); +} + template void DoSerialise(SerialiserType &ser, VkPhysicalDeviceFragmentDensityMapFeaturesEXT &el) { @@ -9778,6 +9853,7 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceDescriptorIndexingProperties) INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceDiscardRectanglePropertiesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceDriverProperties); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalBufferInfo); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalFenceInfo); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceExternalImageFormatInfo); @@ -9862,6 +9938,7 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeatures); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVariablePointerFeatures); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan11Features); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan11Properties); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan12Features); @@ -9958,6 +10035,8 @@ INSTANTIATE_SERIALISE_TYPE(VkTimelineSemaphoreSubmitInfo); INSTANTIATE_SERIALISE_TYPE(VkValidationCacheCreateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkValidationFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkValidationFlagsEXT); +INSTANTIATE_SERIALISE_TYPE(VkVertexInputAttributeDescription2EXT); +INSTANTIATE_SERIALISE_TYPE(VkVertexInputBindingDescription2EXT); INSTANTIATE_SERIALISE_TYPE(VkWriteDescriptorSet); // plain structs with no next chain diff --git a/renderdoc/driver/vulkan/vk_shaderdebug.cpp b/renderdoc/driver/vulkan/vk_shaderdebug.cpp index 277908fa4..0c35aba05 100644 --- a/renderdoc/driver/vulkan/vk_shaderdebug.cpp +++ b/renderdoc/driver/vulkan/vk_shaderdebug.cpp @@ -3919,7 +3919,7 @@ ShaderDebugTrace *VulkanReplay::DebugVertex(uint32_t eventId, uint32_t vertid, u bool found = false; - for(const VulkanCreationInfo::Pipeline::Binding &bind : pipe.vertexBindings) + for(const VulkanCreationInfo::Pipeline::VertBinding &bind : pipe.vertexBindings) { if(bind.vbufferBinding != attr.binding) continue; diff --git a/renderdoc/driver/vulkan/vk_state.cpp b/renderdoc/driver/vulkan/vk_state.cpp index cbcea9ea4..b41aaa379 100644 --- a/renderdoc/driver/vulkan/vk_state.cpp +++ b/renderdoc/driver/vulkan/vk_state.cpp @@ -225,6 +225,20 @@ void VulkanRenderState::BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd, } } + if(vk->ExtendedDynamicState2()) + { + if(dynamicStates[VkDynamicDepthBiasEnableEXT]) + ObjDisp(cmd)->CmdSetDepthBiasEnableEXT(Unwrap(cmd), depthBiasEnable); + if(dynamicStates[VkDynamicLogicOpEXT]) + ObjDisp(cmd)->CmdSetLogicOpEXT(Unwrap(cmd), logicOp); + if(dynamicStates[VkDynamicControlPointsEXT]) + ObjDisp(cmd)->CmdSetPatchControlPointsEXT(Unwrap(cmd), patchControlPoints); + if(dynamicStates[VkDynamicPrimRestartEXT]) + ObjDisp(cmd)->CmdSetPrimitiveRestartEnableEXT(Unwrap(cmd), primRestartEnable); + if(dynamicStates[VkDynamicRastDiscardEXT]) + ObjDisp(cmd)->CmdSetRasterizerDiscardEnableEXT(Unwrap(cmd), rastDiscardEnable); + } + if(dynamicStates[VkDynamicLineWidth]) ObjDisp(cmd)->CmdSetLineWidth(Unwrap(cmd), lineWidth); @@ -288,6 +302,13 @@ void VulkanRenderState::BindPipeline(WrappedVulkan *vk, VkCommandBuffer cmd, ibuffer.offs, type); } + if(vk->DynamicVertexInput() && dynamicStates[VkDynamicVertexInputEXT]) + { + ObjDisp(cmd)->CmdSetVertexInputEXT(Unwrap(cmd), (uint32_t)vertexBindings.size(), + vertexBindings.data(), (uint32_t)vertexAttributes.size(), + vertexAttributes.data()); + } + bool dynamicStride = dynamicStates[VkDynamicVertexInputBindingStrideEXT] && vk->ExtendedDynamicState(); diff --git a/renderdoc/driver/vulkan/vk_state.h b/renderdoc/driver/vulkan/vk_state.h index 410f6f787..b14670479 100644 --- a/renderdoc/driver/vulkan/vk_state.h +++ b/renderdoc/driver/vulkan/vk_state.h @@ -194,6 +194,17 @@ struct VulkanRenderState // color write enable rdcarray colorWriteEnable; + // extended dynamic state 2 + VkBool32 depthBiasEnable = VK_FALSE; + VkLogicOp logicOp = VK_LOGIC_OP_MAX_ENUM; + uint32_t patchControlPoints = 0; + VkBool32 primRestartEnable = VK_FALSE; + VkBool32 rastDiscardEnable = VK_FALSE; + + // dynamic vertex input + rdcarray vertexBindings; + rdcarray vertexAttributes; + private: ResourceId framebuffer; rdcarray fbattachments; diff --git a/renderdoc/driver/vulkan/vk_stringise.cpp b/renderdoc/driver/vulkan/vk_stringise.cpp index 07238c405..a0da49117 100644 --- a/renderdoc/driver/vulkan/vk_stringise.cpp +++ b/renderdoc/driver/vulkan/vk_stringise.cpp @@ -28,7 +28,7 @@ template <> rdcstr DoStringise(const VulkanChunk &el) { - RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1167, "Chunks changed without updating names"); + RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1173, "Chunks changed without updating names"); BEGIN_ENUM_STRINGISE(VulkanChunk) { @@ -199,6 +199,12 @@ rdcstr DoStringise(const VulkanChunk &el) STRINGISE_ENUM_CLASS(vkQueueSubmit2KHR); STRINGISE_ENUM_CLASS(vkCmdWriteBufferMarker2AMD); STRINGISE_ENUM_CLASS(vkCmdSetColorWriteEnableEXT); + STRINGISE_ENUM_CLASS(vkCmdSetDepthBiasEnableEXT) + STRINGISE_ENUM_CLASS(vkCmdSetLogicOpEXT) + STRINGISE_ENUM_CLASS(vkCmdSetPatchControlPointsEXT) + STRINGISE_ENUM_CLASS(vkCmdSetPrimitiveRestartEnableEXT) + STRINGISE_ENUM_CLASS(vkCmdSetRasterizerDiscardEnableEXT) + STRINGISE_ENUM_CLASS(vkCmdSetVertexInputEXT) STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk"); } END_ENUM_STRINGISE() diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index 686912416..c0be96f52 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -2771,7 +2771,7 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu } if(!pipeInfo.dynamicStates[VkDynamicVertexInputBindingStrideEXT]) { - for(const VulkanCreationInfo::Pipeline::Binding &bind : pipeInfo.vertexBindings) + for(const VulkanCreationInfo::Pipeline::VertBinding &bind : pipeInfo.vertexBindings) { renderstate.vbuffers.resize_for_index(bind.vbufferBinding); renderstate.vbuffers[bind.vbufferBinding].stride = bind.bytestride; @@ -2783,6 +2783,53 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu for(size_t i = 0; i < renderstate.colorWriteEnable.size(); i++) renderstate.colorWriteEnable[i] = pipeInfo.attachments[i].channelWriteMask != 0; } + if(!pipeInfo.dynamicStates[VkDynamicDepthBiasEnableEXT]) + { + renderstate.depthBiasEnable = pipeInfo.depthBiasEnable; + } + if(!pipeInfo.dynamicStates[VkDynamicLogicOpEXT]) + { + renderstate.logicOp = pipeInfo.logicOp; + } + if(!pipeInfo.dynamicStates[VkDynamicControlPointsEXT]) + { + renderstate.patchControlPoints = pipeInfo.patchControlPoints; + } + if(!pipeInfo.dynamicStates[VkDynamicPrimRestartEXT]) + { + renderstate.primRestartEnable = pipeInfo.primitiveRestartEnable; + } + if(!pipeInfo.dynamicStates[VkDynamicRastDiscardEXT]) + { + renderstate.rastDiscardEnable = pipeInfo.rasterizerDiscardEnable; + } + if(!pipeInfo.dynamicStates[VkDynamicVertexInputEXT]) + { + renderstate.vertexAttributes.resize(pipeInfo.vertexAttrs.size()); + for(size_t i = 0; i < renderstate.vertexAttributes.size(); i++) + { + renderstate.vertexAttributes[i].sType = + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; + renderstate.vertexAttributes[i].pNext = NULL; + renderstate.vertexAttributes[i].format = pipeInfo.vertexAttrs[i].format; + renderstate.vertexAttributes[i].binding = pipeInfo.vertexAttrs[i].binding; + renderstate.vertexAttributes[i].offset = pipeInfo.vertexAttrs[i].byteoffset; + renderstate.vertexAttributes[i].location = pipeInfo.vertexAttrs[i].location; + } + renderstate.vertexBindings.resize(pipeInfo.vertexBindings.size()); + for(size_t i = 0; i < renderstate.vertexBindings.size(); i++) + { + renderstate.vertexBindings[i].sType = + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; + renderstate.vertexBindings[i].pNext = NULL; + renderstate.vertexBindings[i].binding = pipeInfo.vertexBindings[i].vbufferBinding; + renderstate.vertexBindings[i].inputRate = pipeInfo.vertexBindings[i].perInstance + ? VK_VERTEX_INPUT_RATE_INSTANCE + : VK_VERTEX_INPUT_RATE_VERTEX; + renderstate.vertexBindings[i].stride = pipeInfo.vertexBindings[i].bytestride; + renderstate.vertexBindings[i].divisor = pipeInfo.vertexBindings[i].instanceDivisor; + } + } } } } @@ -3106,7 +3153,15 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers2EXT( // if strides is NULL the pipeline bound must have had no dynamic state for stride and // so stride was filled out then, we leave it as-is. if(pStrides) + { renderstate.vbuffers[firstBinding + i].stride = pStrides[i]; + + // if we have dynamic vertex input data, update the strides. If we don't have any + // that's fine we can skip this, it means the application must provide a later + // vkCmdSetVertexInput which overrides anything we'd set here + if(firstBinding + i < renderstate.vertexBindings.size()) + renderstate.vertexBindings[firstBinding + i].stride = (uint32_t)pStrides[i]; + } } } } @@ -6277,6 +6332,96 @@ void WrappedVulkan::vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffe record->AddChunk(scope.Get(&record->cmdInfo->alloc)); } } +template +bool WrappedVulkan::Serialise_vkCmdSetVertexInputEXT( + SerialiserType &ser, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(vertexBindingDescriptionCount).Important(); + SERIALISE_ELEMENT_ARRAY(pVertexBindingDescriptions, vertexBindingDescriptionCount); + SERIALISE_ELEMENT(vertexAttributeDescriptionCount).Important(); + SERIALISE_ELEMENT_ARRAY(pVertexAttributeDescriptions, vertexAttributeDescriptionCount); + + 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) + ->CmdSetVertexInputEXT(Unwrap(commandBuffer), vertexBindingDescriptionCount, + pVertexBindingDescriptions, vertexAttributeDescriptionCount, + pVertexAttributeDescriptions); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + + renderstate.vertexBindings.assign(pVertexBindingDescriptions, + vertexBindingDescriptionCount); + renderstate.vertexAttributes.assign(pVertexAttributeDescriptions, + vertexAttributeDescriptionCount); + + for(uint32_t i = 0; i < vertexBindingDescriptionCount; i++) + { + // set strides whether or not the vertex buffers have been bound, so that the stride is + // available if a later call to BindVertexBuffers2 doesn't pass any strides (it should + // use the strides from here) + renderstate.vbuffers.resize_for_index(i); + renderstate.vbuffers[i].stride = pVertexBindingDescriptions[i].stride; + } + } + } + } + else + { + ObjDisp(commandBuffer) + ->CmdSetVertexInputEXT(Unwrap(commandBuffer), vertexBindingDescriptionCount, + pVertexBindingDescriptions, vertexAttributeDescriptionCount, + pVertexAttributeDescriptions); + } + } + + return true; +} + +void WrappedVulkan::vkCmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL( + ObjDisp(commandBuffer) + ->CmdSetVertexInputEXT(Unwrap(commandBuffer), vertexBindingDescriptionCount, + pVertexBindingDescriptions, vertexAttributeDescriptionCount, + pVertexAttributeDescriptions)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetVertexInputEXT); + Serialise_vkCmdSetVertexInputEXT(ser, commandBuffer, vertexBindingDescriptionCount, + pVertexBindingDescriptions, vertexAttributeDescriptionCount, + pVertexAttributeDescriptions); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool, VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, @@ -6434,3 +6579,10 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier2KHR, VkCommandBuffer INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdWriteTimestamp2KHR, VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query); + +INSTANTIATE_FUNCTION_SERIALISED( + void, vkCmdSetVertexInputEXT, VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions); diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 6be04b2f2..577c882a7 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -2808,6 +2808,26 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi m_DynColorWrite = (ext->colorWriteEnable != VK_FALSE); } END_PHYS_EXT_CHECK(); + + BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + { + CHECK_PHYS_EXT_FEATURE(extendedDynamicState2); + CHECK_PHYS_EXT_FEATURE(extendedDynamicState2LogicOp); + CHECK_PHYS_EXT_FEATURE(extendedDynamicState2PatchControlPoints); + + m_ExtendedDynState2 = (ext->extendedDynamicState2 != VK_FALSE); + } + END_PHYS_EXT_CHECK(); + + BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT); + { + CHECK_PHYS_EXT_FEATURE(vertexInputDynamicState); + + m_DynVertexInput = (ext->vertexInputDynamicState != VK_FALSE); + } + END_PHYS_EXT_CHECK(); } if(availFeatures.depthClamp) diff --git a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp index f3f38762d..7f6d470ca 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp @@ -1580,6 +1580,311 @@ void WrappedVulkan::vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, } } +template +bool WrappedVulkan::Serialise_vkCmdSetDepthBiasEnableEXT(SerialiserType &ser, + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(depthBiasEnable).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); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.depthBiasEnable = depthBiasEnable; + } + } + else + { + commandBuffer = VK_NULL_HANDLE; + } + } + + if(commandBuffer != VK_NULL_HANDLE) + ObjDisp(commandBuffer)->CmdSetDepthBiasEnableEXT(Unwrap(commandBuffer), depthBiasEnable); + } + + return true; +} + +void WrappedVulkan::vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL( + ObjDisp(commandBuffer)->CmdSetDepthBiasEnableEXT(Unwrap(commandBuffer), depthBiasEnable)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetDepthBiasEnableEXT); + Serialise_vkCmdSetDepthBiasEnableEXT(ser, commandBuffer, depthBiasEnable); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} + +template +bool WrappedVulkan::Serialise_vkCmdSetLogicOpEXT(SerialiserType &ser, VkCommandBuffer commandBuffer, + VkLogicOp logicOp) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(logicOp).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); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.logicOp = logicOp; + } + } + else + { + commandBuffer = VK_NULL_HANDLE; + } + } + + if(commandBuffer != VK_NULL_HANDLE) + ObjDisp(commandBuffer)->CmdSetLogicOpEXT(Unwrap(commandBuffer), logicOp); + } + + return true; +} + +void WrappedVulkan::vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL(ObjDisp(commandBuffer)->CmdSetLogicOpEXT(Unwrap(commandBuffer), logicOp)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetLogicOpEXT); + Serialise_vkCmdSetLogicOpEXT(ser, commandBuffer, logicOp); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} + +template +bool WrappedVulkan::Serialise_vkCmdSetPatchControlPointsEXT(SerialiserType &ser, + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(patchControlPoints).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); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.patchControlPoints = patchControlPoints; + } + } + else + { + commandBuffer = VK_NULL_HANDLE; + } + } + + if(commandBuffer != VK_NULL_HANDLE) + ObjDisp(commandBuffer)->CmdSetPatchControlPointsEXT(Unwrap(commandBuffer), patchControlPoints); + } + + return true; +} + +void WrappedVulkan::vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, + uint32_t patchControlPoints) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL( + ObjDisp(commandBuffer)->CmdSetPatchControlPointsEXT(Unwrap(commandBuffer), patchControlPoints)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetPatchControlPointsEXT); + Serialise_vkCmdSetPatchControlPointsEXT(ser, commandBuffer, patchControlPoints); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} + +template +bool WrappedVulkan::Serialise_vkCmdSetPrimitiveRestartEnableEXT(SerialiserType &ser, + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(primitiveRestartEnable).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); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.primRestartEnable = primitiveRestartEnable; + } + } + else + { + commandBuffer = VK_NULL_HANDLE; + } + } + + if(commandBuffer != VK_NULL_HANDLE) + ObjDisp(commandBuffer) + ->CmdSetPrimitiveRestartEnableEXT(Unwrap(commandBuffer), primitiveRestartEnable); + } + + return true; +} + +void WrappedVulkan::vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL( + ObjDisp(commandBuffer) + ->CmdSetPrimitiveRestartEnableEXT(Unwrap(commandBuffer), primitiveRestartEnable)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetPrimitiveRestartEnableEXT); + Serialise_vkCmdSetPrimitiveRestartEnableEXT(ser, commandBuffer, primitiveRestartEnable); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} + +template +bool WrappedVulkan::Serialise_vkCmdSetRasterizerDiscardEnableEXT(SerialiserType &ser, + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ + SERIALISE_ELEMENT(commandBuffer); + SERIALISE_ELEMENT(rasterizerDiscardEnable).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); + + { + VulkanRenderState &renderstate = GetCmdRenderState(); + renderstate.rastDiscardEnable = rasterizerDiscardEnable; + } + } + else + { + commandBuffer = VK_NULL_HANDLE; + } + } + + if(commandBuffer != VK_NULL_HANDLE) + ObjDisp(commandBuffer) + ->CmdSetRasterizerDiscardEnableEXT(Unwrap(commandBuffer), rasterizerDiscardEnable); + } + + return true; +} + +void WrappedVulkan::vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ + SCOPED_DBG_SINK(); + + SERIALISE_TIME_CALL( + ObjDisp(commandBuffer) + ->CmdSetRasterizerDiscardEnableEXT(Unwrap(commandBuffer), rasterizerDiscardEnable)); + + if(IsCaptureMode(m_State)) + { + VkResourceRecord *record = GetRecord(commandBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetRasterizerDiscardEnableEXT); + Serialise_vkCmdSetRasterizerDiscardEnableEXT(ser, commandBuffer, rasterizerDiscardEnable); + + record->AddChunk(scope.Get(&record->cmdInfo->alloc)); + } +} + INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetViewport, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports); @@ -1656,3 +1961,14 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetStencilOpEXT, VkCommandBuffer comm INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetColorWriteEnableEXT, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetDepthBiasEnableEXT, VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetLogicOpEXT, VkCommandBuffer commandBuffer, + VkLogicOp logicOp); +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetPatchControlPointsEXT, VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetPrimitiveRestartEnableEXT, + VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRasterizerDiscardEnableEXT, + VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); diff --git a/renderdoc/replay/renderdoc_serialise.inl b/renderdoc/replay/renderdoc_serialise.inl index b13441993..b6dff239c 100644 --- a/renderdoc/replay/renderdoc_serialise.inl +++ b/renderdoc/replay/renderdoc_serialise.inl @@ -2132,6 +2132,7 @@ void DoSerialise(SerialiserType &ser, VKPipe::Rasterizer &el) SERIALISE_MEMBER(conservativeRasterization); SERIALISE_MEMBER(extraPrimitiveOverestimationSize); + SERIALISE_MEMBER(depthBiasEnable); SERIALISE_MEMBER(depthBias); SERIALISE_MEMBER(depthBiasClamp); SERIALISE_MEMBER(slopeScaledDepthBias); @@ -2141,7 +2142,7 @@ void DoSerialise(SerialiserType &ser, VKPipe::Rasterizer &el) SERIALISE_MEMBER(lineStippleFactor); SERIALISE_MEMBER(lineStipplePattern); - SIZE_CHECK(48); + SIZE_CHECK(52); } template @@ -2326,7 +2327,7 @@ void DoSerialise(SerialiserType &ser, VKPipe::State &el) SERIALISE_MEMBER(conditionalRendering); - SIZE_CHECK(2000); + SIZE_CHECK(2008); } #pragma endregion Vulkan pipeline state