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

Support VK_EXT_dynamic_state2 & VK_EXT_vertex_input_dynamic_state

Browse Source
This commit is contained in:
baldurk
2021-10-22 16:22:42 +01:00
parent 7a4e68959f
commit d00556dbb5
20 changed files with 777 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
qrenderdoc/Windows/PipelineState/VulkanPipelineStateViewer.cpp
+25 -6
View File
@@ -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;
renderdoc/api/replay/vk_pipestate.h
+2
View File
@@ -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
renderdoc/driver/vulkan/extension_support.md
+2 -2
View File
@@ -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
renderdoc/driver/vulkan/vk_common.h
+14
View File
@@ -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);
renderdoc/driver/vulkan/vk_core.cpp
+20
View File
@@ -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:
renderdoc/driver/vulkan/vk_core.h
+26
View File
@@ -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);
};
renderdoc/driver/vulkan/vk_hookset_defs.h
+26 -3
View File
@@ -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(); \
renderdoc/driver/vulkan/vk_info.h
+2 -2
View File
@@ -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<Binding> vertexBindings;
rdcarray<VertBinding> vertexBindings;
struct Attribute
{
renderdoc/driver/vulkan/vk_next_chains.cpp
+8 -4
View File
@@ -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:
renderdoc/driver/vulkan/vk_overlay.cpp
+27 -1
View File
@@ -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)
renderdoc/driver/vulkan/vk_replay.cpp
+6 -4
View File
@@ -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 =
renderdoc/driver/vulkan/vk_serialise.cpp
+87 -8
View File
@@ -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 <typename SerialiserType>
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 <typename SerialiserType>
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 <typename SerialiserType>
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 <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkPhysicalDevice8BitStorageFeatures &el)
{
@@ -5243,6 +5300,24 @@ void Deserialise(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &el)
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
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 <typename SerialiserType>
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
renderdoc/driver/vulkan/vk_shaderdebug.cpp
+1 -1
View File
@@ -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;
renderdoc/driver/vulkan/vk_state.cpp
+21
View File
@@ -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();
renderdoc/driver/vulkan/vk_state.h
+11
View File
@@ -194,6 +194,17 @@ struct VulkanRenderState
// color write enable
rdcarray<VkBool32> 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<VkVertexInputBindingDescription2EXT> vertexBindings;
rdcarray<VkVertexInputAttributeDescription2EXT> vertexAttributes;
private:
ResourceId framebuffer;
rdcarray<ResourceId> fbattachments;
renderdoc/driver/vulkan/vk_stringise.cpp
+7 -1
View File
@@ -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()
renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp
+153 -1
View File
@@ -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 <typename SerialiserType>
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);
renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp
+20
View File
@@ -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)
renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp
+316
View File
@@ -1580,6 +1580,311 @@ void WrappedVulkan::vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer,
}
}
template <typename SerialiserType>
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 <typename SerialiserType>
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 <typename SerialiserType>
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 <typename SerialiserType>
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 <typename SerialiserType>
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);
renderdoc/replay/renderdoc_serialise.inl
+3 -2
View File
@@ -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 <typename SerialiserType>
@@ -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