From b5d9ccb5b25c47665438b9c0fe186c8a0c7d93e8 Mon Sep 17 00:00:00 2001 From: Amer Koleci Date: Thu, 3 Oct 2024 09:48:19 +0200 Subject: [PATCH] Update vulkan headers to 1.3.296 and bump version to 1.9.8 --- README.md | 2 +- src/Generator/vulkan/vulkan_core.h | 346 +++++++++++++- src/Vortice.Vulkan/Generated/Commands.cs | 86 ++++ src/Vortice.Vulkan/Generated/Constants.cs | 60 ++- src/Vortice.Vulkan/Generated/Enumerations.cs | 126 ++++++ src/Vortice.Vulkan/Generated/Handles.cs | 50 +++ src/Vortice.Vulkan/Generated/Structures.cs | 449 +++++++++++++++++++ src/Vortice.Vulkan/Vortice.Vulkan.csproj | 2 +- 8 files changed, 1117 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index be366d3..cc025a2 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/amerkoleci/Vortice.Vulkan/blob/main/LICENSE) [![Build status](https://github.com/amerkoleci/Vortice.Vulkan/workflows/Build/badge.svg)](https://github.com/amerkoleci/Vortice.Vulkan/actions) -[![Vulkan](https://img.shields.io/badge/vulkan-1.3.295-brightgreen.svg)](https://www.khronos.org/vulkan/) +[![Vulkan](https://img.shields.io/badge/vulkan-1.3.296-brightgreen.svg)](https://www.khronos.org/vulkan/) [![NuGet](https://img.shields.io/nuget/v/Vortice.Vulkan.svg)](https://www.nuget.org/packages/Vortice.Vulkan) **Vortice.Vulkan** is **.NET 8** and **.NET 9** low-level bindings for [Vulkan](https://www.khronos.org/vulkan/), [VulkanMemoryAllocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator), [SPIRV-Cross](https://github.com/KhronosGroup/SPIRV-Cross) and [shaderc](https://github.com/google/shaderc). diff --git a/src/Generator/vulkan/vulkan_core.h b/src/Generator/vulkan/vulkan_core.h index 6f1c17f..e6c1649 100644 --- a/src/Generator/vulkan/vulkan_core.h +++ b/src/Generator/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 295 +#define VK_HEADER_VERSION 296 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -1143,9 +1143,25 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias @@ -1436,6 +1452,8 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, + VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, @@ -2013,6 +2031,7 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000, + VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000, VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, @@ -2248,6 +2267,8 @@ typedef enum VkAccessFlagBits { VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAccessFlagBits; typedef VkFlags VkAccessFlags; @@ -2472,6 +2493,7 @@ typedef enum VkPipelineStageFlagBits { VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineStageFlagBits; typedef VkFlags VkPipelineStageFlags; @@ -6655,6 +6677,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 0x00020000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; @@ -6731,6 +6754,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_ static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; @@ -11201,6 +11226,7 @@ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; typedef VkFlags64 VkBufferUsageFlags2KHR; @@ -11233,6 +11259,7 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUF static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR { VkStructureType sType; @@ -18858,6 +18885,12 @@ typedef enum VkShaderCodeTypeEXT { VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF } VkShaderCodeTypeEXT; +typedef enum VkDepthClampModeEXT { + VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0, + VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1, + VK_DEPTH_CLAMP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDepthClampModeEXT; + typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, @@ -18866,6 +18899,7 @@ typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkShaderCreateFlagBitsEXT; typedef VkFlags VkShaderCreateFlagsEXT; @@ -18901,10 +18935,16 @@ typedef struct VkShaderCreateInfoEXT { typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; +typedef struct VkDepthClampRangeEXT { + float minDepthClamp; + float maxDepthClamp; +} VkDepthClampRangeEXT; + typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( @@ -18930,6 +18970,11 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); #endif @@ -19511,6 +19556,286 @@ typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV { +// VK_EXT_device_generated_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT) +#define VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1 +#define VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_EXT_device_generated_commands" + +typedef enum VkIndirectExecutionSetInfoTypeEXT { + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectExecutionSetInfoTypeEXT; + +typedef enum VkIndirectCommandsTokenTypeEXT { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeEXT; + +typedef enum VkIndirectCommandsInputModeFlagBitsEXT { + VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsInputModeFlagBitsEXT; +typedef VkFlags VkIndirectCommandsInputModeFlagsEXT; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsEXT { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsEXT; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT; +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT { + VkStructureType sType; + void* pNext; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; +} VkGeneratedCommandsMemoryRequirementsInfoEXT; + +typedef struct VkIndirectExecutionSetPipelineInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipeline initialPipeline; + uint32_t maxPipelineCount; +} VkIndirectExecutionSetPipelineInfoEXT; + +typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkIndirectExecutionSetShaderLayoutInfoEXT; + +typedef struct VkIndirectExecutionSetShaderInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t shaderCount; + const VkShaderEXT* pInitialShaders; + const VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkIndirectExecutionSetShaderInfoEXT; + +typedef union VkIndirectExecutionSetInfoEXT { + const VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; + const VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; +} VkIndirectExecutionSetInfoEXT; + +typedef struct VkIndirectExecutionSetCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkIndirectExecutionSetInfoTypeEXT type; + VkIndirectExecutionSetInfoEXT info; +} VkIndirectExecutionSetCreateInfoEXT; + +typedef struct VkGeneratedCommandsInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + VkDeviceAddress indirectAddress; + VkDeviceSize indirectAddressSize; + VkDeviceAddress preprocessAddress; + VkDeviceSize preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress sequenceCountAddress; + uint32_t maxDrawCount; +} VkGeneratedCommandsInfoEXT; + +typedef struct VkWriteIndirectExecutionSetPipelineEXT { + VkStructureType sType; + const void* pNext; + uint32_t index; + VkPipeline pipeline; +} VkWriteIndirectExecutionSetPipelineEXT; + +typedef struct VkIndirectCommandsPushConstantTokenEXT { + VkPushConstantRange updateRange; +} VkIndirectCommandsPushConstantTokenEXT; + +typedef struct VkIndirectCommandsVertexBufferTokenEXT { + uint32_t vertexBindingUnit; +} VkIndirectCommandsVertexBufferTokenEXT; + +typedef struct VkIndirectCommandsIndexBufferTokenEXT { + VkIndirectCommandsInputModeFlagBitsEXT mode; +} VkIndirectCommandsIndexBufferTokenEXT; + +typedef struct VkIndirectCommandsExecutionSetTokenEXT { + VkIndirectExecutionSetInfoTypeEXT type; + VkShaderStageFlags shaderStages; +} VkIndirectCommandsExecutionSetTokenEXT; + +typedef union VkIndirectCommandsTokenDataEXT { + const VkIndirectCommandsPushConstantTokenEXT* pPushConstant; + const VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; + const VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; + const VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; +} VkIndirectCommandsTokenDataEXT; + +typedef struct VkIndirectCommandsLayoutTokenEXT { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsTokenTypeEXT type; + VkIndirectCommandsTokenDataEXT data; + uint32_t offset; +} VkIndirectCommandsLayoutTokenEXT; + +typedef struct VkIndirectCommandsLayoutCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout pipelineLayout; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenEXT* pTokens; +} VkIndirectCommandsLayoutCreateInfoEXT; + +typedef struct VkDrawIndirectCountIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t stride; + uint32_t commandCount; +} VkDrawIndirectCountIndirectCommandEXT; + +typedef struct VkBindVertexBufferIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandEXT; + +typedef struct VkBindIndexBufferIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandEXT; + +typedef struct VkGeneratedCommandsPipelineInfoEXT { + VkStructureType sType; + void* pNext; + VkPipeline pipeline; +} VkGeneratedCommandsPipelineInfoEXT; + +typedef struct VkGeneratedCommandsShaderInfoEXT { + VkStructureType sType; + void* pNext; + uint32_t shaderCount; + const VkShaderEXT* pShaders; +} VkGeneratedCommandsShaderInfoEXT; + +typedef struct VkWriteIndirectExecutionSetShaderEXT { + VkStructureType sType; + const void* pNext; + uint32_t index; + VkShaderEXT shader; +} VkWriteIndirectExecutionSetShaderEXT; + +typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutEXT)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectExecutionSetEXT)(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectExecutionSetEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); + +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); +#endif + + // VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls. #define VK_MESA_image_alignment_control 1 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1 @@ -19535,6 +19860,25 @@ typedef struct VkImageAlignmentControlCreateInfoMESA { +// VK_EXT_depth_clamp_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_clamp_control 1 +#define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" +typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClampControl; +} VkPhysicalDeviceDepthClampControlFeaturesEXT; + +typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDepthClampModeEXT depthClampMode; + const VkDepthClampRangeEXT* pDepthClampRange; +} VkPipelineViewportDepthClampControlCreateInfoEXT; + + + // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_acceleration_structure 1 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 diff --git a/src/Vortice.Vulkan/Generated/Commands.cs b/src/Vortice.Vulkan/Generated/Commands.cs index dd3734b..ba301b0 100644 --- a/src/Vortice.Vulkan/Generated/Commands.cs +++ b/src/Vortice.Vulkan/Generated/Commands.cs @@ -612,6 +612,7 @@ unsafe partial class Vulkan private static delegate* unmanaged vkDestroyShaderEXT_ptr; private static delegate* unmanaged vkGetShaderBinaryDataEXT_ptr; private static delegate* unmanaged vkCmdBindShadersEXT_ptr; + private static delegate* unmanaged vkCmdSetDepthClampRangeEXT_ptr; private static delegate* unmanaged vkGetFramebufferTilePropertiesQCOM_ptr; private static delegate* unmanaged vkGetDynamicRenderingTilePropertiesQCOM_ptr; private static delegate* unmanaged vkSetLatencySleepModeNV_ptr; @@ -620,6 +621,15 @@ unsafe partial class Vulkan private static delegate* unmanaged vkGetLatencyTimingsNV_ptr; private static delegate* unmanaged vkQueueNotifyOutOfBandNV_ptr; private static delegate* unmanaged vkCmdSetAttachmentFeedbackLoopEnableEXT_ptr; + private static delegate* unmanaged vkGetGeneratedCommandsMemoryRequirementsEXT_ptr; + private static delegate* unmanaged vkCmdPreprocessGeneratedCommandsEXT_ptr; + private static delegate* unmanaged vkCmdExecuteGeneratedCommandsEXT_ptr; + private static delegate* unmanaged vkCreateIndirectCommandsLayoutEXT_ptr; + private static delegate* unmanaged vkDestroyIndirectCommandsLayoutEXT_ptr; + private static delegate* unmanaged vkCreateIndirectExecutionSetEXT_ptr; + private static delegate* unmanaged vkDestroyIndirectExecutionSetEXT_ptr; + private static delegate* unmanaged vkUpdateIndirectExecutionSetPipelineEXT_ptr; + private static delegate* unmanaged vkUpdateIndirectExecutionSetShaderEXT_ptr; private static delegate* unmanaged vkCreateAccelerationStructureKHR_ptr; private static delegate* unmanaged vkDestroyAccelerationStructureKHR_ptr; private static delegate* unmanaged vkCmdBuildAccelerationStructuresKHR_ptr; @@ -4812,6 +4822,11 @@ public static void vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint stage vkCmdBindShadersEXT_ptr(commandBuffer, stageCount, stages, shaders); } + public static void vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, VkDepthClampRangeEXT* depthClampRange) + { + vkCmdSetDepthClampRangeEXT_ptr(commandBuffer, depthClampMode, depthClampRange); + } + public static VkResult vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint* propertiesCount, VkTilePropertiesQCOM* properties) { return vkGetFramebufferTilePropertiesQCOM_ptr(device, framebuffer, propertiesCount, properties); @@ -4852,6 +4867,67 @@ public static void vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer comma vkCmdSetAttachmentFeedbackLoopEnableEXT_ptr(commandBuffer, aspectMask); } + public static void vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, VkGeneratedCommandsMemoryRequirementsInfoEXT* info, VkMemoryRequirements2* memoryRequirements) + { + vkGetGeneratedCommandsMemoryRequirementsEXT_ptr(device, info, memoryRequirements); + } + + public static void vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkGeneratedCommandsInfoEXT* generatedCommandsInfo, VkCommandBuffer stateCommandBuffer) + { + vkCmdPreprocessGeneratedCommandsEXT_ptr(commandBuffer, generatedCommandsInfo, stateCommandBuffer); + } + + public static void vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, VkGeneratedCommandsInfoEXT* generatedCommandsInfo) + { + vkCmdExecuteGeneratedCommandsEXT_ptr(commandBuffer, isPreprocessed, generatedCommandsInfo); + } + + public static VkResult vkCreateIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutCreateInfoEXT* createInfo, VkAllocationCallbacks* allocator, VkIndirectCommandsLayoutEXT* indirectCommandsLayout) + { + return vkCreateIndirectCommandsLayoutEXT_ptr(device, createInfo, allocator, indirectCommandsLayout); + } + + public static VkResult vkCreateIndirectCommandsLayoutEXT(VkDevice device, in VkIndirectCommandsLayoutCreateInfoEXT createInfo, VkAllocationCallbacks* allocator, VkIndirectCommandsLayoutEXT* indirectCommandsLayout) + { + fixed (VkIndirectCommandsLayoutCreateInfoEXT* createInfoPtr = &createInfo) + { + return vkCreateIndirectCommandsLayoutEXT_ptr(device, createInfoPtr, allocator, indirectCommandsLayout); + } + } + + public static void vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, VkAllocationCallbacks* allocator = default) + { + vkDestroyIndirectCommandsLayoutEXT_ptr(device, indirectCommandsLayout, allocator); + } + + public static VkResult vkCreateIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetCreateInfoEXT* createInfo, VkAllocationCallbacks* allocator, VkIndirectExecutionSetEXT* indirectExecutionSet) + { + return vkCreateIndirectExecutionSetEXT_ptr(device, createInfo, allocator, indirectExecutionSet); + } + + public static VkResult vkCreateIndirectExecutionSetEXT(VkDevice device, in VkIndirectExecutionSetCreateInfoEXT createInfo, VkAllocationCallbacks* allocator, VkIndirectExecutionSetEXT* indirectExecutionSet) + { + fixed (VkIndirectExecutionSetCreateInfoEXT* createInfoPtr = &createInfo) + { + return vkCreateIndirectExecutionSetEXT_ptr(device, createInfoPtr, allocator, indirectExecutionSet); + } + } + + public static void vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, VkAllocationCallbacks* allocator = default) + { + vkDestroyIndirectExecutionSetEXT_ptr(device, indirectExecutionSet, allocator); + } + + public static void vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint executionSetWriteCount, VkWriteIndirectExecutionSetPipelineEXT* executionSetWrites) + { + vkUpdateIndirectExecutionSetPipelineEXT_ptr(device, indirectExecutionSet, executionSetWriteCount, executionSetWrites); + } + + public static void vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint executionSetWriteCount, VkWriteIndirectExecutionSetShaderEXT* executionSetWrites) + { + vkUpdateIndirectExecutionSetShaderEXT_ptr(device, indirectExecutionSet, executionSetWriteCount, executionSetWrites); + } + public static VkResult vkCreateAccelerationStructureKHR(VkDevice device, VkAccelerationStructureCreateInfoKHR* createInfo, VkAllocationCallbacks* allocator, VkAccelerationStructureKHR* accelerationStructure) { return vkCreateAccelerationStructureKHR_ptr(device, createInfo, allocator, accelerationStructure); @@ -5944,6 +6020,7 @@ private static void GenLoadDevice(IntPtr context, LoadFunction load) vkDestroyShaderEXT_ptr = (delegate* unmanaged) load(context, nameof(vkDestroyShaderEXT)); vkGetShaderBinaryDataEXT_ptr = (delegate* unmanaged) load(context, nameof(vkGetShaderBinaryDataEXT)); vkCmdBindShadersEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCmdBindShadersEXT)); + vkCmdSetDepthClampRangeEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCmdSetDepthClampRangeEXT)); vkGetFramebufferTilePropertiesQCOM_ptr = (delegate* unmanaged) load(context, nameof(vkGetFramebufferTilePropertiesQCOM)); vkGetDynamicRenderingTilePropertiesQCOM_ptr = (delegate* unmanaged) load(context, nameof(vkGetDynamicRenderingTilePropertiesQCOM)); vkSetLatencySleepModeNV_ptr = (delegate* unmanaged) load(context, nameof(vkSetLatencySleepModeNV)); @@ -5952,6 +6029,15 @@ private static void GenLoadDevice(IntPtr context, LoadFunction load) vkGetLatencyTimingsNV_ptr = (delegate* unmanaged) load(context, nameof(vkGetLatencyTimingsNV)); vkQueueNotifyOutOfBandNV_ptr = (delegate* unmanaged) load(context, nameof(vkQueueNotifyOutOfBandNV)); vkCmdSetAttachmentFeedbackLoopEnableEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCmdSetAttachmentFeedbackLoopEnableEXT)); + vkGetGeneratedCommandsMemoryRequirementsEXT_ptr = (delegate* unmanaged) load(context, nameof(vkGetGeneratedCommandsMemoryRequirementsEXT)); + vkCmdPreprocessGeneratedCommandsEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCmdPreprocessGeneratedCommandsEXT)); + vkCmdExecuteGeneratedCommandsEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCmdExecuteGeneratedCommandsEXT)); + vkCreateIndirectCommandsLayoutEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCreateIndirectCommandsLayoutEXT)); + vkDestroyIndirectCommandsLayoutEXT_ptr = (delegate* unmanaged) load(context, nameof(vkDestroyIndirectCommandsLayoutEXT)); + vkCreateIndirectExecutionSetEXT_ptr = (delegate* unmanaged) load(context, nameof(vkCreateIndirectExecutionSetEXT)); + vkDestroyIndirectExecutionSetEXT_ptr = (delegate* unmanaged) load(context, nameof(vkDestroyIndirectExecutionSetEXT)); + vkUpdateIndirectExecutionSetPipelineEXT_ptr = (delegate* unmanaged) load(context, nameof(vkUpdateIndirectExecutionSetPipelineEXT)); + vkUpdateIndirectExecutionSetShaderEXT_ptr = (delegate* unmanaged) load(context, nameof(vkUpdateIndirectExecutionSetShaderEXT)); vkCreateAccelerationStructureKHR_ptr = (delegate* unmanaged) load(context, nameof(vkCreateAccelerationStructureKHR)); vkDestroyAccelerationStructureKHR_ptr = (delegate* unmanaged) load(context, nameof(vkDestroyAccelerationStructureKHR)); vkCmdBuildAccelerationStructuresKHR_ptr = (delegate* unmanaged) load(context, nameof(vkCmdBuildAccelerationStructuresKHR)); diff --git a/src/Vortice.Vulkan/Generated/Constants.cs b/src/Vortice.Vulkan/Generated/Constants.cs index 8420044..8b9213e 100644 --- a/src/Vortice.Vulkan/Generated/Constants.cs +++ b/src/Vortice.Vulkan/Generated/Constants.cs @@ -15,7 +15,7 @@ namespace Vortice.Vulkan; public static partial class Vulkan { /// VK_HEADER_VERSION - public const uint VK_HEADER_VERSION = 295; + public const uint VK_HEADER_VERSION = 296; /// VK_HEADER_VERSION_COMPLETE public static readonly VkVersion VK_HEADER_VERSION_COMPLETE = new VkVersion(0, 1, 3, VK_HEADER_VERSION); /// VK_ATTACHMENT_UNUSED @@ -2284,12 +2284,24 @@ public static partial class Vulkan public const uint VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION = 1; /// VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME public static ReadOnlySpan VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME => "VK_NV_ray_tracing_validation"u8; + /// VK_EXT_device_generated_commands + public const uint VK_EXT_device_generated_commands = 1; + /// VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION + public const uint VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 1; + /// VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + public static ReadOnlySpan VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME => "VK_EXT_device_generated_commands"u8; /// VK_MESA_image_alignment_control public const uint VK_MESA_image_alignment_control = 1; /// VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION public const uint VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION = 1; /// VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME public static ReadOnlySpan VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME => "VK_MESA_image_alignment_control"u8; + /// VK_EXT_depth_clamp_control + public const uint VK_EXT_depth_clamp_control = 1; + /// VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION + public const uint VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION = 1; + /// VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME + public static ReadOnlySpan VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME => "VK_EXT_depth_clamp_control"u8; /// VK_KHR_acceleration_structure public const uint VK_KHR_acceleration_structure = 1; /// VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION @@ -3419,9 +3431,25 @@ public static partial class Vulkan public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = VkStructureType.PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = VkStructureType.PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = VkStructureType.PhysicalDeviceRayTracingValidationFeaturesNV; + public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = VkStructureType.PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = VkStructureType.PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + public const VkStructureType VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = VkStructureType.GeneratedCommandsMemoryRequirementsInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = VkStructureType.IndirectExecutionSetCreateInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = VkStructureType.GeneratedCommandsInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = VkStructureType.IndirectCommandsLayoutCreateInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = VkStructureType.IndirectCommandsLayoutTokenEXT; + public const VkStructureType VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = VkStructureType.WriteIndirectExecutionSetPipelineEXT; + public const VkStructureType VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = VkStructureType.WriteIndirectExecutionSetShaderEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = VkStructureType.IndirectExecutionSetPipelineInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = VkStructureType.IndirectExecutionSetShaderInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = VkStructureType.IndirectExecutionSetShaderLayoutInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = VkStructureType.GeneratedCommandsPipelineInfoEXT; + public const VkStructureType VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = VkStructureType.GeneratedCommandsShaderInfoEXT; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = VkStructureType.PhysicalDeviceImageAlignmentControlFeaturesMESA; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = VkStructureType.PhysicalDeviceImageAlignmentControlPropertiesMESA; public const VkStructureType VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = VkStructureType.ImageAlignmentControlCreateInfoMESA; + public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = VkStructureType.PhysicalDeviceDepthClampControlFeaturesEXT; + public const VkStructureType VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = VkStructureType.PipelineViewportDepthClampControlCreateInfoEXT; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VkStructureType.PhysicalDeviceVariablePointerFeatures; public const VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VkStructureType.PhysicalDeviceShaderDrawParameterFeatures; public const VkStructureType VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VkStructureType.DebugReportCreateInfoEXT; @@ -3696,6 +3724,8 @@ public static partial class Vulkan public const VkObjectType VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = VkObjectType.OpticalFlowSessionNV; public const VkObjectType VK_OBJECT_TYPE_SHADER_EXT = VkObjectType.ShaderEXT; public const VkObjectType VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = VkObjectType.PipelineBinaryKHR; + public const VkObjectType VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = VkObjectType.IndirectCommandsLayoutEXT; + public const VkObjectType VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = VkObjectType.IndirectExecutionSetEXT; public const VkObjectType VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VkObjectType.DescriptorUpdateTemplateKHR; public const VkObjectType VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VkObjectType.SamplerYcbcrConversionKHR; public const VkObjectType VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VkObjectType.PrivateDataSlotEXT; @@ -4212,6 +4242,7 @@ public static partial class Vulkan public const VkDynamicState VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = VkDynamicState.CoverageReductionModeNV; public const VkDynamicState VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = VkDynamicState.AttachmentFeedbackLoopEnableEXT; public const VkDynamicState VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VkDynamicState.LineStippleKHR; + public const VkDynamicState VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = VkDynamicState.DepthClampRangeEXT; public const VkDynamicState VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VkDynamicState.LineStippleEXT; public const VkDynamicState VK_DYNAMIC_STATE_CULL_MODE_EXT = VkDynamicState.CullModeEXT; public const VkDynamicState VK_DYNAMIC_STATE_FRONT_FACE_EXT = VkDynamicState.FrontFaceEXT; @@ -4372,6 +4403,8 @@ public static partial class Vulkan public const VkAccessFlags VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VkAccessFlags.AccelerationStructureReadNV; public const VkAccessFlags VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VkAccessFlags.AccelerationStructureWriteNV; public const VkAccessFlags VK_ACCESS_NONE_KHR = VkAccessFlags.NoneKHR; + public const VkAccessFlags VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = VkAccessFlags.CommandPreprocessReadEXT; + public const VkAccessFlags VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = VkAccessFlags.CommandPreprocessWriteEXT; public const VkImageAspectFlags VK_IMAGE_ASPECT_COLOR_BIT = VkImageAspectFlags.Color; public const VkImageAspectFlags VK_IMAGE_ASPECT_DEPTH_BIT = VkImageAspectFlags.Depth; public const VkImageAspectFlags VK_IMAGE_ASPECT_STENCIL_BIT = VkImageAspectFlags.Stencil; @@ -4540,6 +4573,7 @@ public static partial class Vulkan public const VkPipelineStageFlags VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VkPipelineStageFlags.TaskShaderNV; public const VkPipelineStageFlags VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VkPipelineStageFlags.MeshShaderNV; public const VkPipelineStageFlags VK_PIPELINE_STAGE_NONE_KHR = VkPipelineStageFlags.NoneKHR; + public const VkPipelineStageFlags VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = VkPipelineStageFlags.CommandPreprocessEXT; public const VkMemoryMapFlags VK_MEMORY_MAP_PLACED_BIT_EXT = VkMemoryMapFlags.PlacedEXT; public const VkSparseMemoryBindFlags VK_SPARSE_MEMORY_BIND_METADATA_BIT = VkSparseMemoryBindFlags.Metadata; public const VkSparseImageFormatFlags VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = VkSparseImageFormatFlags.SingleMiptail; @@ -5878,6 +5912,8 @@ public static partial class Vulkan public const VkAntiLagStageAMD VK_ANTI_LAG_STAGE_PRESENT_AMD = VkAntiLagStageAMD.PresentAMD; public const VkShaderCodeTypeEXT VK_SHADER_CODE_TYPE_BINARY_EXT = VkShaderCodeTypeEXT.Binary; public const VkShaderCodeTypeEXT VK_SHADER_CODE_TYPE_SPIRV_EXT = VkShaderCodeTypeEXT.SPIRV; + public const VkDepthClampModeEXT VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = VkDepthClampModeEXT.ViewportRange; + public const VkDepthClampModeEXT VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = VkDepthClampModeEXT.UserDefinedRange; public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = VkShaderCreateFlagsEXT.LinkStage; public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VkShaderCreateFlagsEXT.AllowVaryingSubgroupSize; public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VkShaderCreateFlagsEXT.RequireFullSubgroups; @@ -5885,6 +5921,7 @@ public static partial class Vulkan public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = VkShaderCreateFlagsEXT.DispatchBase; public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = VkShaderCreateFlagsEXT.FragmentShadingRateAttachment; public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VkShaderCreateFlagsEXT.FragmentDensityMapAttachment; + public const VkShaderCreateFlagsEXT VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = VkShaderCreateFlagsEXT.IndirectBindable; public const VkRayTracingInvocationReorderModeNV VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = VkRayTracingInvocationReorderModeNV.ModeNone; public const VkRayTracingInvocationReorderModeNV VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = VkRayTracingInvocationReorderModeNV.ModeReorder; public const VkLayerSettingTypeEXT VK_LAYER_SETTING_TYPE_BOOL32_EXT = VkLayerSettingTypeEXT.Bool32; @@ -5920,6 +5957,27 @@ public static partial class Vulkan public const VkLayeredDriverUnderlyingApiMSFT VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = VkLayeredDriverUnderlyingApiMSFT.VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT; public const VkLayeredDriverUnderlyingApiMSFT VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = VkLayeredDriverUnderlyingApiMSFT.VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT; public const VkLayeredDriverUnderlyingApiMSFT VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = VkLayeredDriverUnderlyingApiMSFT.VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT; + public const VkIndirectExecutionSetInfoTypeEXT VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = VkIndirectExecutionSetInfoTypeEXT.Pipelines; + public const VkIndirectExecutionSetInfoTypeEXT VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = VkIndirectExecutionSetInfoTypeEXT.ShaderObjects; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = VkIndirectCommandsTokenTypeEXT.ExecutionSet; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = VkIndirectCommandsTokenTypeEXT.PushConstant; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = VkIndirectCommandsTokenTypeEXT.SequenceIndex; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = VkIndirectCommandsTokenTypeEXT.IndexBuffer; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = VkIndirectCommandsTokenTypeEXT.VertexBuffer; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = VkIndirectCommandsTokenTypeEXT.DrawIndexed; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = VkIndirectCommandsTokenTypeEXT.Draw; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = VkIndirectCommandsTokenTypeEXT.DrawIndexedCount; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = VkIndirectCommandsTokenTypeEXT.DrawCount; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = VkIndirectCommandsTokenTypeEXT.Dispatch; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = VkIndirectCommandsTokenTypeEXT.DrawMeshTasksNV; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = VkIndirectCommandsTokenTypeEXT.DrawMeshTasksCountNV; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = VkIndirectCommandsTokenTypeEXT.DrawMeshTasks; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = VkIndirectCommandsTokenTypeEXT.DrawMeshTasksCount; + public const VkIndirectCommandsTokenTypeEXT VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = VkIndirectCommandsTokenTypeEXT.TraceRays2; + public const VkIndirectCommandsInputModeFlagsEXT VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = VkIndirectCommandsInputModeFlagsEXT.VulkanIndexBuffer; + public const VkIndirectCommandsInputModeFlagsEXT VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = VkIndirectCommandsInputModeFlagsEXT.DxgiIndexBuffer; + public const VkIndirectCommandsLayoutUsageFlagsEXT VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = VkIndirectCommandsLayoutUsageFlagsEXT.ExplicitPreprocess; + public const VkIndirectCommandsLayoutUsageFlagsEXT VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = VkIndirectCommandsLayoutUsageFlagsEXT.UnorderedSequences; public const VkBuildAccelerationStructureModeKHR VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = VkBuildAccelerationStructureModeKHR.Build; public const VkBuildAccelerationStructureModeKHR VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = VkBuildAccelerationStructureModeKHR.Update; public const VkAccelerationStructureCreateFlagsKHR VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VkAccelerationStructureCreateFlagsKHR.DeviceAddressCaptureReplay; diff --git a/src/Vortice.Vulkan/Generated/Enumerations.cs b/src/Vortice.Vulkan/Generated/Enumerations.cs index 0c9a221..e8d7211 100644 --- a/src/Vortice.Vulkan/Generated/Enumerations.cs +++ b/src/Vortice.Vulkan/Generated/Enumerations.cs @@ -2038,12 +2038,44 @@ public enum VkStructureType PhysicalDeviceShaderReplicatedCompositesFeaturesEXT = 1000564000, /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV PhysicalDeviceRayTracingValidationFeaturesNV = 1000568000, + /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT = 1000572000, + /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT = 1000572001, + /// VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT + GeneratedCommandsMemoryRequirementsInfoEXT = 1000572002, + /// VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT + IndirectExecutionSetCreateInfoEXT = 1000572003, + /// VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT + GeneratedCommandsInfoEXT = 1000572004, + /// VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT + IndirectCommandsLayoutCreateInfoEXT = 1000572006, + /// VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT + IndirectCommandsLayoutTokenEXT = 1000572007, + /// VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT + WriteIndirectExecutionSetPipelineEXT = 1000572008, + /// VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT + WriteIndirectExecutionSetShaderEXT = 1000572009, + /// VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT + IndirectExecutionSetPipelineInfoEXT = 1000572010, + /// VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT + IndirectExecutionSetShaderInfoEXT = 1000572011, + /// VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT + IndirectExecutionSetShaderLayoutInfoEXT = 1000572012, + /// VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT + GeneratedCommandsPipelineInfoEXT = 1000572013, + /// VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT + GeneratedCommandsShaderInfoEXT = 1000572014, /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA PhysicalDeviceImageAlignmentControlFeaturesMESA = 1000575000, /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA PhysicalDeviceImageAlignmentControlPropertiesMESA = 1000575001, /// VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA ImageAlignmentControlCreateInfoMESA = 1000575002, + /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT + PhysicalDeviceDepthClampControlFeaturesEXT = 1000582000, + /// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT + PipelineViewportDepthClampControlCreateInfoEXT = 1000582001, /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures, /// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES @@ -2634,6 +2666,10 @@ public enum VkObjectType ShaderEXT = 1000482000, /// VK_OBJECT_TYPE_PIPELINE_BINARY_KHR PipelineBinaryKHR = 1000483000, + /// VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT + IndirectCommandsLayoutEXT = 1000572000, + /// VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT + IndirectExecutionSetEXT = 1000572001, /// VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate, /// VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR @@ -3756,6 +3792,8 @@ public enum VkDynamicState AttachmentFeedbackLoopEnableEXT = 1000524000, /// VK_DYNAMIC_STATE_LINE_STIPPLE_KHR LineStippleKHR = 1000259000, + /// VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT + DepthClampRangeEXT = 1000582000, /// VK_DYNAMIC_STATE_LINE_STIPPLE_EXT LineStippleEXT = LineStippleKHR, /// VK_DYNAMIC_STATE_CULL_MODE_EXT @@ -4206,6 +4244,10 @@ public enum VkAccessFlags AccelerationStructureWriteNV = AccelerationStructureWriteKHR, /// VK_ACCESS_NONE_KHR NoneKHR = None, + /// VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT + CommandPreprocessReadEXT = CommandPreprocessReadNV, + /// VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT + CommandPreprocessWriteEXT = CommandPreprocessWriteNV, } [Flags] @@ -4786,6 +4828,8 @@ public enum VkPipelineStageFlags MeshShaderNV = MeshShaderEXT, /// VK_PIPELINE_STAGE_NONE_KHR NoneKHR = None, + /// VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT + CommandPreprocessEXT = CommandPreprocessNV, } [Flags] @@ -8858,6 +8902,14 @@ public enum VkShaderCodeTypeEXT SPIRV = 1, } +public enum VkDepthClampModeEXT +{ + /// VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT + ViewportRange = 0, + /// VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT + UserDefinedRange = 1, +} + [Flags] public enum VkShaderCreateFlagsEXT { @@ -8876,6 +8928,8 @@ public enum VkShaderCreateFlagsEXT FragmentShadingRateAttachment = 0x00000020, /// VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT FragmentDensityMapAttachment = 0x00000040, + /// VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT + IndirectBindable = 0x00000080, } public enum VkRayTracingInvocationReorderModeNV @@ -8976,6 +9030,68 @@ public enum VkLayeredDriverUnderlyingApiMSFT VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF, } +public enum VkIndirectExecutionSetInfoTypeEXT +{ + /// VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT + Pipelines = 0, + /// VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT + ShaderObjects = 1, +} + +public enum VkIndirectCommandsTokenTypeEXT +{ + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT + ExecutionSet = 0, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT + PushConstant = 1, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT + SequenceIndex = 2, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT + IndexBuffer = 3, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT + VertexBuffer = 4, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT + DrawIndexed = 5, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT + Draw = 6, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT + DrawIndexedCount = 7, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT + DrawCount = 8, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT + Dispatch = 9, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT + DrawMeshTasksNV = 1000202002, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT + DrawMeshTasksCountNV = 1000202003, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT + DrawMeshTasks = 1000328000, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT + DrawMeshTasksCount = 1000328001, + /// VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT + TraceRays2 = 1000386004, +} + +[Flags] +public enum VkIndirectCommandsInputModeFlagsEXT +{ + None = 0, + /// VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT + VulkanIndexBuffer = 0x00000001, + /// VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT + DxgiIndexBuffer = 0x00000002, +} + +[Flags] +public enum VkIndirectCommandsLayoutUsageFlagsEXT +{ + None = 0, + /// VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT + ExplicitPreprocess = 0x00000001, + /// VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT + UnorderedSequences = 0x00000002, +} + public enum VkBuildAccelerationStructureModeKHR { /// VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR @@ -9579,6 +9695,8 @@ public enum VkPipelineStageFlags2 : ulong ConditionalRenderingEXT = 0x00040000UL, /// VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV CommandPreprocessNV = 0x00020000UL, + /// VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT + CommandPreprocessEXT = 0x00020000UL, /// VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR FragmentShadingRateAttachmentKHR = 0x00400000UL, /// VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV @@ -9724,6 +9842,10 @@ public enum VkAccessFlags2 : ulong CommandPreprocessReadNV = 0x00020000UL, /// VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV CommandPreprocessWriteNV = 0x00040000UL, + /// VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT + CommandPreprocessReadEXT = 0x00020000UL, + /// VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT + CommandPreprocessWriteEXT = 0x00040000UL, /// VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR FragmentShadingRateAttachmentReadKHR = 0x00800000UL, /// VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV @@ -9970,6 +10092,8 @@ public enum VkPipelineCreateFlags2KHR : ulong DescriptorBufferEXT = 0x20000000UL, /// VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR CaptureData = 0x80000000UL, + /// VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT + IndirectBindableEXT = 0x4000000000UL, } [Flags] @@ -10029,6 +10153,8 @@ public enum VkBufferUsageFlags2KHR : ulong MicromapBuildInputReadOnlyEXT = 0x00800000UL, /// VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT MicromapStorageEXT = 0x01000000UL, + /// VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT + PreprocessBufferEXT = 0x80000000UL, } [Flags] diff --git a/src/Vortice.Vulkan/Generated/Handles.cs b/src/Vortice.Vulkan/Generated/Handles.cs index 5cf8ac8..c137c9e 100644 --- a/src/Vortice.Vulkan/Generated/Handles.cs +++ b/src/Vortice.Vulkan/Generated/Handles.cs @@ -1288,6 +1288,56 @@ namespace Vortice.Vulkan; private string DebuggerDisplay => $"{nameof(VkShaderEXT)} [0x{Handle.ToString("X")}]"; } +/// +/// A non-dispatchable handle. +/// +[DebuggerDisplay("{DebuggerDisplay,nq}")] +public readonly partial struct VkIndirectExecutionSetEXT : IEquatable +{ + public VkIndirectExecutionSetEXT(ulong handle) { Handle = handle; } + public ulong Handle { get; } + public bool IsNull => Handle == 0; + public bool IsNotNull => Handle != 0; + public static VkIndirectExecutionSetEXT Null => new(0); + public static implicit operator VkIndirectExecutionSetEXT(ulong handle) => new(handle); + public static implicit operator ulong(VkIndirectExecutionSetEXT handle) => handle.Handle; + public static bool operator ==(VkIndirectExecutionSetEXT left, VkIndirectExecutionSetEXT right) => left.Handle == right.Handle; + public static bool operator !=(VkIndirectExecutionSetEXT left, VkIndirectExecutionSetEXT right) => left.Handle != right.Handle; + public static bool operator ==(VkIndirectExecutionSetEXT left, ulong right) => left.Handle == right; + public static bool operator !=(VkIndirectExecutionSetEXT left, ulong right) => left.Handle != right; + public bool Equals(VkIndirectExecutionSetEXT other) => Handle == other.Handle; + /// + public override bool Equals(object? obj) => obj is VkIndirectExecutionSetEXT handle && Equals(handle); + /// + public override int GetHashCode() => Handle.GetHashCode(); + private string DebuggerDisplay => $"{nameof(VkIndirectExecutionSetEXT)} [0x{Handle.ToString("X")}]"; +} + +/// +/// A non-dispatchable handle. +/// +[DebuggerDisplay("{DebuggerDisplay,nq}")] +public readonly partial struct VkIndirectCommandsLayoutEXT : IEquatable +{ + public VkIndirectCommandsLayoutEXT(ulong handle) { Handle = handle; } + public ulong Handle { get; } + public bool IsNull => Handle == 0; + public bool IsNotNull => Handle != 0; + public static VkIndirectCommandsLayoutEXT Null => new(0); + public static implicit operator VkIndirectCommandsLayoutEXT(ulong handle) => new(handle); + public static implicit operator ulong(VkIndirectCommandsLayoutEXT handle) => handle.Handle; + public static bool operator ==(VkIndirectCommandsLayoutEXT left, VkIndirectCommandsLayoutEXT right) => left.Handle == right.Handle; + public static bool operator !=(VkIndirectCommandsLayoutEXT left, VkIndirectCommandsLayoutEXT right) => left.Handle != right.Handle; + public static bool operator ==(VkIndirectCommandsLayoutEXT left, ulong right) => left.Handle == right; + public static bool operator !=(VkIndirectCommandsLayoutEXT left, ulong right) => left.Handle != right; + public bool Equals(VkIndirectCommandsLayoutEXT other) => Handle == other.Handle; + /// + public override bool Equals(object? obj) => obj is VkIndirectCommandsLayoutEXT handle && Equals(handle); + /// + public override int GetHashCode() => Handle.GetHashCode(); + private string DebuggerDisplay => $"{nameof(VkIndirectCommandsLayoutEXT)} [0x{Handle.ToString("X")}]"; +} + /// /// A non-dispatchable handle. /// diff --git a/src/Vortice.Vulkan/Generated/Structures.cs b/src/Vortice.Vulkan/Generated/Structures.cs index 03473b4..daca438 100644 --- a/src/Vortice.Vulkan/Generated/Structures.cs +++ b/src/Vortice.Vulkan/Generated/Structures.cs @@ -20650,6 +20650,12 @@ public VkShaderCreateInfoEXT() } } +public partial struct VkDepthClampRangeEXT +{ + public float minDepthClamp; + public float maxDepthClamp; +} + public unsafe partial struct VkPhysicalDeviceTilePropertiesFeaturesQCOM : IStructureType, IChainType { public VkStructureType sType = VkStructureType.PhysicalDeviceTilePropertiesFeaturesQCOM; @@ -21635,6 +21641,406 @@ public VkPhysicalDeviceRayTracingValidationFeaturesNV() } } +public unsafe partial struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + public void* pNext; + public VkBool32 deviceGeneratedCommands; + public VkBool32 dynamicGeneratedPipelineLayout; + + public VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + public void* pNext; + public uint maxIndirectPipelineCount; + public uint maxIndirectShaderObjectCount; + public uint maxIndirectSequenceCount; + public uint maxIndirectCommandsTokenCount; + public uint maxIndirectCommandsTokenOffset; + public uint maxIndirectCommandsIndirectStride; + public VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + public VkShaderStageFlags supportedIndirectCommandsShaderStages; + public VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + public VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + public VkBool32 deviceGeneratedCommandsTransformFeedback; + public VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; + + public VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkGeneratedCommandsMemoryRequirementsInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.GeneratedCommandsMemoryRequirementsInfoEXT; + public void* pNext; + public VkIndirectExecutionSetEXT indirectExecutionSet; + public VkIndirectCommandsLayoutEXT indirectCommandsLayout; + public uint maxSequenceCount; + public uint maxDrawCount; + + public VkGeneratedCommandsMemoryRequirementsInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkIndirectExecutionSetPipelineInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectExecutionSetPipelineInfoEXT; + public void* pNext; + public VkPipeline initialPipeline; + public uint maxPipelineCount; + + public VkIndirectExecutionSetPipelineInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkIndirectExecutionSetShaderLayoutInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectExecutionSetShaderLayoutInfoEXT; + public void* pNext; + public uint setLayoutCount; + public VkDescriptorSetLayout* pSetLayouts; + + public VkIndirectExecutionSetShaderLayoutInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkIndirectExecutionSetShaderInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectExecutionSetShaderInfoEXT; + public void* pNext; + public uint shaderCount; + public VkShaderEXT* pInitialShaders; + public VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos; + public uint maxShaderCount; + public uint pushConstantRangeCount; + public VkPushConstantRange* pPushConstantRanges; + + public VkIndirectExecutionSetShaderInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +[StructLayout(LayoutKind.Explicit)] +public unsafe partial struct VkIndirectExecutionSetInfoEXT +{ + [FieldOffset(0)] + public VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; + [FieldOffset(0)] + public VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; +} + +public unsafe partial struct VkIndirectExecutionSetCreateInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectExecutionSetCreateInfoEXT; + public void* pNext; + public VkIndirectExecutionSetInfoTypeEXT type; + public VkIndirectExecutionSetInfoEXT info; + + public VkIndirectExecutionSetCreateInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkGeneratedCommandsInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.GeneratedCommandsInfoEXT; + public void* pNext; + public VkShaderStageFlags shaderStages; + public VkIndirectExecutionSetEXT indirectExecutionSet; + public VkIndirectCommandsLayoutEXT indirectCommandsLayout; + public ulong indirectAddress; + public ulong indirectAddressSize; + public ulong preprocessAddress; + public ulong preprocessSize; + public uint maxSequenceCount; + public ulong sequenceCountAddress; + public uint maxDrawCount; + + public VkGeneratedCommandsInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkWriteIndirectExecutionSetPipelineEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.WriteIndirectExecutionSetPipelineEXT; + public void* pNext; + public uint index; + public VkPipeline pipeline; + + public VkWriteIndirectExecutionSetPipelineEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public partial struct VkIndirectCommandsPushConstantTokenEXT +{ + public VkPushConstantRange updateRange; +} + +public partial struct VkIndirectCommandsVertexBufferTokenEXT +{ + public uint vertexBindingUnit; +} + +public partial struct VkIndirectCommandsIndexBufferTokenEXT +{ + public VkIndirectCommandsInputModeFlagsEXT mode; +} + +public partial struct VkIndirectCommandsExecutionSetTokenEXT +{ + public VkIndirectExecutionSetInfoTypeEXT type; + public VkShaderStageFlags shaderStages; +} + +[StructLayout(LayoutKind.Explicit)] +public unsafe partial struct VkIndirectCommandsTokenDataEXT +{ + [FieldOffset(0)] + public VkIndirectCommandsPushConstantTokenEXT* pPushConstant; + [FieldOffset(0)] + public VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; + [FieldOffset(0)] + public VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; + [FieldOffset(0)] + public VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; +} + +public unsafe partial struct VkIndirectCommandsLayoutTokenEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectCommandsLayoutTokenEXT; + public void* pNext; + public VkIndirectCommandsTokenTypeEXT type; + public VkIndirectCommandsTokenDataEXT data; + public uint offset; + + public VkIndirectCommandsLayoutTokenEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkIndirectCommandsLayoutCreateInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.IndirectCommandsLayoutCreateInfoEXT; + public void* pNext; + public VkIndirectCommandsLayoutUsageFlagsEXT flags; + public VkShaderStageFlags shaderStages; + public uint indirectStride; + public VkPipelineLayout pipelineLayout; + public uint tokenCount; + public VkIndirectCommandsLayoutTokenEXT* pTokens; + + public VkIndirectCommandsLayoutCreateInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public partial struct VkDrawIndirectCountIndirectCommandEXT +{ + public ulong bufferAddress; + public uint stride; + public uint commandCount; +} + +public partial struct VkBindVertexBufferIndirectCommandEXT +{ + public ulong bufferAddress; + public uint size; + public uint stride; +} + +public partial struct VkBindIndexBufferIndirectCommandEXT +{ + public ulong bufferAddress; + public uint size; + public VkIndexType indexType; +} + +public unsafe partial struct VkGeneratedCommandsPipelineInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.GeneratedCommandsPipelineInfoEXT; + public void* pNext; + public VkPipeline pipeline; + + public VkGeneratedCommandsPipelineInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkGeneratedCommandsShaderInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.GeneratedCommandsShaderInfoEXT; + public void* pNext; + public uint shaderCount; + public VkShaderEXT* pShaders; + + public VkGeneratedCommandsShaderInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkWriteIndirectExecutionSetShaderEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.WriteIndirectExecutionSetShaderEXT; + public void* pNext; + public uint index; + public VkShaderEXT shader; + + public VkWriteIndirectExecutionSetShaderEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + public unsafe partial struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA : IStructureType, IChainType { public VkStructureType sType = VkStructureType.PhysicalDeviceImageAlignmentControlFeaturesMESA; @@ -21698,6 +22104,49 @@ public VkImageAlignmentControlCreateInfoMESA() } } +public unsafe partial struct VkPhysicalDeviceDepthClampControlFeaturesEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.PhysicalDeviceDepthClampControlFeaturesEXT; + public void* pNext; + public VkBool32 depthClampControl; + + public VkPhysicalDeviceDepthClampControlFeaturesEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + +public unsafe partial struct VkPipelineViewportDepthClampControlCreateInfoEXT : IStructureType, IChainType +{ + public VkStructureType sType = VkStructureType.PipelineViewportDepthClampControlCreateInfoEXT; + public void* pNext; + public VkDepthClampModeEXT depthClampMode; + public VkDepthClampRangeEXT* pDepthClampRange; + + public VkPipelineViewportDepthClampControlCreateInfoEXT() + { + } + + /// + VkStructureType IStructureType.sType => sType; + + /// + void* IChainType.pNext + { + get => pNext; + set => pNext = value; + } +} + public partial struct VkAccelerationStructureBuildRangeInfoKHR { public uint primitiveCount; diff --git a/src/Vortice.Vulkan/Vortice.Vulkan.csproj b/src/Vortice.Vulkan/Vortice.Vulkan.csproj index 0d7eff6..8c70a3a 100644 --- a/src/Vortice.Vulkan/Vortice.Vulkan.csproj +++ b/src/Vortice.Vulkan/Vortice.Vulkan.csproj @@ -10,7 +10,7 @@ - 1.9.7 + 1.9.8