diff options
Diffstat (limited to 'include/vulkan/vulkan.hpp')
| -rw-r--r-- | include/vulkan/vulkan.hpp | 1503 |
1 files changed, 822 insertions, 681 deletions
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 2073f3d..64aa226 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include <compare> #endif -static_assert( VK_HEADER_VERSION == 175, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 176, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -2280,6 +2280,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); } + void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable ); + } + void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT @@ -2385,6 +2390,17 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); } + void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp ); + } + + void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, + uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints ); + } + VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT @@ -2405,12 +2421,24 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo ); } + void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable ); + } + void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT { return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology ); } + void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable ); + } + void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT { @@ -5600,47 +5628,47 @@ namespace VULKAN_HPP_NAMESPACE enum class AccessFlagBits2KHR : VkAccessFlags2KHR { // clang-format off - e2None = VK_ACCESS_2_NONE_KHR - , e2IndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR - , e2IndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR - , e2VertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR - , e2UniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR - , e2InputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR - , e2ShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR - , e2ShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR - , e2ColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR - , e2ColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR - , e2DepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR - , e2DepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR - , e2TransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR - , e2TransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR - , e2HostRead = VK_ACCESS_2_HOST_READ_BIT_KHR - , e2HostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR - , e2MemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR - , e2MemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR - , e2ShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR - , e2ShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR - , e2ShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR + eNone = VK_ACCESS_2_NONE_KHR + , eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR + , eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR + , eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR + , eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR + , eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR + , eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR + , eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR + , eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR + , eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR + , eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR + , eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR + , eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR + , eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR + , eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR + , eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR + , eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR + , eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR + , eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR + , eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR + , eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR #if defined( VK_ENABLE_BETA_EXTENSIONS ) - , e2VideoDecodeRead = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR - , e2VideoDecodeWrite = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR - , e2VideoEncodeRead = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR - , e2VideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR + , eVideoDecodeRead = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR + , eVideoDecodeWrite = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR + , eVideoEncodeRead = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR + , eVideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , e2TransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT - , e2TransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT - , e2TransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT - , e2ConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT - , e2CommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV - , e2CommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV - , e2FragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR - , e2AccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR - , e2AccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR - , e2FragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT - , e2ColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT - , e2AccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV - , e2AccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV - , e2ShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV + , eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT + , eTransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT + , eTransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT + , eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT + , eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV + , eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV + , eFragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR + , eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR + , eAccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR + , eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT + , eColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT + , eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV + , eAccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV + , eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV // clang-format on }; @@ -5648,44 +5676,44 @@ namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case AccessFlagBits2KHR::e2None: return "2None"; - case AccessFlagBits2KHR::e2IndirectCommandRead: return "2IndirectCommandRead"; - case AccessFlagBits2KHR::e2IndexRead: return "2IndexRead"; - case AccessFlagBits2KHR::e2VertexAttributeRead: return "2VertexAttributeRead"; - case AccessFlagBits2KHR::e2UniformRead: return "2UniformRead"; - case AccessFlagBits2KHR::e2InputAttachmentRead: return "2InputAttachmentRead"; - case AccessFlagBits2KHR::e2ShaderRead: return "2ShaderRead"; - case AccessFlagBits2KHR::e2ShaderWrite: return "2ShaderWrite"; - case AccessFlagBits2KHR::e2ColorAttachmentRead: return "2ColorAttachmentRead"; - case AccessFlagBits2KHR::e2ColorAttachmentWrite: return "2ColorAttachmentWrite"; - case AccessFlagBits2KHR::e2DepthStencilAttachmentRead: return "2DepthStencilAttachmentRead"; - case AccessFlagBits2KHR::e2DepthStencilAttachmentWrite: return "2DepthStencilAttachmentWrite"; - case AccessFlagBits2KHR::e2TransferRead: return "2TransferRead"; - case AccessFlagBits2KHR::e2TransferWrite: return "2TransferWrite"; - case AccessFlagBits2KHR::e2HostRead: return "2HostRead"; - case AccessFlagBits2KHR::e2HostWrite: return "2HostWrite"; - case AccessFlagBits2KHR::e2MemoryRead: return "2MemoryRead"; - case AccessFlagBits2KHR::e2MemoryWrite: return "2MemoryWrite"; - case AccessFlagBits2KHR::e2ShaderSampledRead: return "2ShaderSampledRead"; - case AccessFlagBits2KHR::e2ShaderStorageRead: return "2ShaderStorageRead"; - case AccessFlagBits2KHR::e2ShaderStorageWrite: return "2ShaderStorageWrite"; + case AccessFlagBits2KHR::eNone: return "None"; + case AccessFlagBits2KHR::eIndirectCommandRead: return "IndirectCommandRead"; + case AccessFlagBits2KHR::eIndexRead: return "IndexRead"; + case AccessFlagBits2KHR::eVertexAttributeRead: return "VertexAttributeRead"; + case AccessFlagBits2KHR::eUniformRead: return "UniformRead"; + case AccessFlagBits2KHR::eInputAttachmentRead: return "InputAttachmentRead"; + case AccessFlagBits2KHR::eShaderRead: return "ShaderRead"; + case AccessFlagBits2KHR::eShaderWrite: return "ShaderWrite"; + case AccessFlagBits2KHR::eColorAttachmentRead: return "ColorAttachmentRead"; + case AccessFlagBits2KHR::eColorAttachmentWrite: return "ColorAttachmentWrite"; + case AccessFlagBits2KHR::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead"; + case AccessFlagBits2KHR::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite"; + case AccessFlagBits2KHR::eTransferRead: return "TransferRead"; + case AccessFlagBits2KHR::eTransferWrite: return "TransferWrite"; + case AccessFlagBits2KHR::eHostRead: return "HostRead"; + case AccessFlagBits2KHR::eHostWrite: return "HostWrite"; + case AccessFlagBits2KHR::eMemoryRead: return "MemoryRead"; + case AccessFlagBits2KHR::eMemoryWrite: return "MemoryWrite"; + case AccessFlagBits2KHR::eShaderSampledRead: return "ShaderSampledRead"; + case AccessFlagBits2KHR::eShaderStorageRead: return "ShaderStorageRead"; + case AccessFlagBits2KHR::eShaderStorageWrite: return "ShaderStorageWrite"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) - case AccessFlagBits2KHR::e2VideoDecodeRead: return "2VideoDecodeRead"; - case AccessFlagBits2KHR::e2VideoDecodeWrite: return "2VideoDecodeWrite"; - case AccessFlagBits2KHR::e2VideoEncodeRead: return "2VideoEncodeRead"; - case AccessFlagBits2KHR::e2VideoEncodeWrite: return "2VideoEncodeWrite"; + case AccessFlagBits2KHR::eVideoDecodeRead: return "VideoDecodeRead"; + case AccessFlagBits2KHR::eVideoDecodeWrite: return "VideoDecodeWrite"; + case AccessFlagBits2KHR::eVideoEncodeRead: return "VideoEncodeRead"; + case AccessFlagBits2KHR::eVideoEncodeWrite: return "VideoEncodeWrite"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case AccessFlagBits2KHR::e2TransformFeedbackWriteExt: return "2TransformFeedbackWriteExt"; - case AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt: return "2TransformFeedbackCounterReadExt"; - case AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt: return "2TransformFeedbackCounterWriteExt"; - case AccessFlagBits2KHR::e2ConditionalRenderingReadExt: return "2ConditionalRenderingReadExt"; - case AccessFlagBits2KHR::e2CommandPreprocessReadNv: return "2CommandPreprocessReadNv"; - case AccessFlagBits2KHR::e2CommandPreprocessWriteNv: return "2CommandPreprocessWriteNv"; - case AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead: return "2FragmentShadingRateAttachmentRead"; - case AccessFlagBits2KHR::e2AccelerationStructureRead: return "2AccelerationStructureRead"; - case AccessFlagBits2KHR::e2AccelerationStructureWrite: return "2AccelerationStructureWrite"; - case AccessFlagBits2KHR::e2FragmentDensityMapReadExt: return "2FragmentDensityMapReadExt"; - case AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt: return "2ColorAttachmentReadNoncoherentExt"; + case AccessFlagBits2KHR::eTransformFeedbackWriteExt: return "TransformFeedbackWriteExt"; + case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt: return "TransformFeedbackCounterReadExt"; + case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt: return "TransformFeedbackCounterWriteExt"; + case AccessFlagBits2KHR::eConditionalRenderingReadExt: return "ConditionalRenderingReadExt"; + case AccessFlagBits2KHR::eCommandPreprocessReadNv: return "CommandPreprocessReadNv"; + case AccessFlagBits2KHR::eCommandPreprocessWriteNv: return "CommandPreprocessWriteNv"; + case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead: return "FragmentShadingRateAttachmentRead"; + case AccessFlagBits2KHR::eAccelerationStructureRead: return "AccelerationStructureRead"; + case AccessFlagBits2KHR::eAccelerationStructureWrite: return "AccelerationStructureWrite"; + case AccessFlagBits2KHR::eFragmentDensityMapReadExt: return "FragmentDensityMapReadExt"; + case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt: return "ColorAttachmentReadNoncoherentExt"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -7012,6 +7040,11 @@ namespace VULKAN_HPP_NAMESPACE eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT, eVertexInputEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, + ePatchControlPointsEXT = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT, + eRasterizerDiscardEnableEXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT, + eDepthBiasEnableEXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, + eLogicOpEXT = VK_DYNAMIC_STATE_LOGIC_OP_EXT, + ePrimitiveRestartEnableEXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT }; @@ -7050,6 +7083,11 @@ namespace VULKAN_HPP_NAMESPACE case DynamicState::eStencilTestEnableEXT: return "StencilTestEnableEXT"; case DynamicState::eStencilOpEXT: return "StencilOpEXT"; case DynamicState::eVertexInputEXT: return "VertexInputEXT"; + case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT"; + case DynamicState::eRasterizerDiscardEnableEXT: return "RasterizerDiscardEnableEXT"; + case DynamicState::eDepthBiasEnableEXT: return "DepthBiasEnableEXT"; + case DynamicState::eLogicOpEXT: return "LogicOpEXT"; + case DynamicState::ePrimitiveRestartEnableEXT: return "PrimitiveRestartEnableEXT"; case DynamicState::eColorWriteEnableEXT: return "ColorWriteEnableEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } @@ -9226,48 +9264,48 @@ namespace VULKAN_HPP_NAMESPACE enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR { // clang-format off - e2None = VK_PIPELINE_STAGE_2_NONE_KHR - , e2TopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR - , e2DrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR - , e2VertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR - , e2VertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR - , e2TessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR - , e2TessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR - , e2GeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR - , e2FragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR - , e2EarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR - , e2LateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR - , e2ColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR - , e2ComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR - , e2AllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR - , e2BottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR - , e2Host = VK_PIPELINE_STAGE_2_HOST_BIT_KHR - , e2AllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR - , e2AllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR - , e2Copy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR - , e2Resolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR - , e2Blit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR - , e2Clear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR - , e2IndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR - , e2VertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR - , e2PreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR + eNone = VK_PIPELINE_STAGE_2_NONE_KHR + , eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR + , eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR + , eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR + , eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR + , eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR + , eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR + , eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR + , eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR + , eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR + , eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR + , eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR + , eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR + , eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR + , eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR + , eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR + , eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR + , eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR + , eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR + , eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR + , eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR + , eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR + , eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR + , eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR + , ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR #if defined( VK_ENABLE_BETA_EXTENSIONS ) - , e2VideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR - , e2VideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR + , eVideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR + , eVideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , e2TransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT - , e2ConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT - , e2CommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV - , e2FragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR - , e2AccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR - , e2RayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR - , e2FragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT - , e2TaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV - , e2MeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV - , e2AccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV - , e2RayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV - , e2ShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV - , e2Transfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR + , eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT + , eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT + , eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV + , eFragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR + , eAccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR + , eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR + , eFragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT + , eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV + , eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV + , eAccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV + , eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV + , eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV + , eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR // clang-format on }; @@ -9275,44 +9313,44 @@ namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case PipelineStageFlagBits2KHR::e2None: return "2None"; - case PipelineStageFlagBits2KHR::e2TopOfPipe: return "2TopOfPipe"; - case PipelineStageFlagBits2KHR::e2DrawIndirect: return "2DrawIndirect"; - case PipelineStageFlagBits2KHR::e2VertexInput: return "2VertexInput"; - case PipelineStageFlagBits2KHR::e2VertexShader: return "2VertexShader"; - case PipelineStageFlagBits2KHR::e2TessellationControlShader: return "2TessellationControlShader"; - case PipelineStageFlagBits2KHR::e2TessellationEvaluationShader: return "2TessellationEvaluationShader"; - case PipelineStageFlagBits2KHR::e2GeometryShader: return "2GeometryShader"; - case PipelineStageFlagBits2KHR::e2FragmentShader: return "2FragmentShader"; - case PipelineStageFlagBits2KHR::e2EarlyFragmentTests: return "2EarlyFragmentTests"; - case PipelineStageFlagBits2KHR::e2LateFragmentTests: return "2LateFragmentTests"; - case PipelineStageFlagBits2KHR::e2ColorAttachmentOutput: return "2ColorAttachmentOutput"; - case PipelineStageFlagBits2KHR::e2ComputeShader: return "2ComputeShader"; - case PipelineStageFlagBits2KHR::e2AllTransfer: return "2AllTransfer"; - case PipelineStageFlagBits2KHR::e2BottomOfPipe: return "2BottomOfPipe"; - case PipelineStageFlagBits2KHR::e2Host: return "2Host"; - case PipelineStageFlagBits2KHR::e2AllGraphics: return "2AllGraphics"; - case PipelineStageFlagBits2KHR::e2AllCommands: return "2AllCommands"; - case PipelineStageFlagBits2KHR::e2Copy: return "2Copy"; - case PipelineStageFlagBits2KHR::e2Resolve: return "2Resolve"; - case PipelineStageFlagBits2KHR::e2Blit: return "2Blit"; - case PipelineStageFlagBits2KHR::e2Clear: return "2Clear"; - case PipelineStageFlagBits2KHR::e2IndexInput: return "2IndexInput"; - case PipelineStageFlagBits2KHR::e2VertexAttributeInput: return "2VertexAttributeInput"; - case PipelineStageFlagBits2KHR::e2PreRasterizationShaders: return "2PreRasterizationShaders"; + case PipelineStageFlagBits2KHR::eNone: return "None"; + case PipelineStageFlagBits2KHR::eTopOfPipe: return "TopOfPipe"; + case PipelineStageFlagBits2KHR::eDrawIndirect: return "DrawIndirect"; + case PipelineStageFlagBits2KHR::eVertexInput: return "VertexInput"; + case PipelineStageFlagBits2KHR::eVertexShader: return "VertexShader"; + case PipelineStageFlagBits2KHR::eTessellationControlShader: return "TessellationControlShader"; + case PipelineStageFlagBits2KHR::eTessellationEvaluationShader: return "TessellationEvaluationShader"; + case PipelineStageFlagBits2KHR::eGeometryShader: return "GeometryShader"; + case PipelineStageFlagBits2KHR::eFragmentShader: return "FragmentShader"; + case PipelineStageFlagBits2KHR::eEarlyFragmentTests: return "EarlyFragmentTests"; + case PipelineStageFlagBits2KHR::eLateFragmentTests: return "LateFragmentTests"; + case PipelineStageFlagBits2KHR::eColorAttachmentOutput: return "ColorAttachmentOutput"; + case PipelineStageFlagBits2KHR::eComputeShader: return "ComputeShader"; + case PipelineStageFlagBits2KHR::eAllTransfer: return "AllTransfer"; + case PipelineStageFlagBits2KHR::eBottomOfPipe: return "BottomOfPipe"; + case PipelineStageFlagBits2KHR::eHost: return "Host"; + case PipelineStageFlagBits2KHR::eAllGraphics: return "AllGraphics"; + case PipelineStageFlagBits2KHR::eAllCommands: return "AllCommands"; + case PipelineStageFlagBits2KHR::eCopy: return "Copy"; + case PipelineStageFlagBits2KHR::eResolve: return "Resolve"; + case PipelineStageFlagBits2KHR::eBlit: return "Blit"; + case PipelineStageFlagBits2KHR::eClear: return "Clear"; + case PipelineStageFlagBits2KHR::eIndexInput: return "IndexInput"; + case PipelineStageFlagBits2KHR::eVertexAttributeInput: return "VertexAttributeInput"; + case PipelineStageFlagBits2KHR::ePreRasterizationShaders: return "PreRasterizationShaders"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) - case PipelineStageFlagBits2KHR::e2VideoDecode: return "2VideoDecode"; - case PipelineStageFlagBits2KHR::e2VideoEncode: return "2VideoEncode"; + case PipelineStageFlagBits2KHR::eVideoDecode: return "VideoDecode"; + case PipelineStageFlagBits2KHR::eVideoEncode: return "VideoEncode"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case PipelineStageFlagBits2KHR::e2TransformFeedbackExt: return "2TransformFeedbackExt"; - case PipelineStageFlagBits2KHR::e2ConditionalRenderingExt: return "2ConditionalRenderingExt"; - case PipelineStageFlagBits2KHR::e2CommandPreprocessNv: return "2CommandPreprocessNv"; - case PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment: return "2FragmentShadingRateAttachment"; - case PipelineStageFlagBits2KHR::e2AccelerationStructureBuild: return "2AccelerationStructureBuild"; - case PipelineStageFlagBits2KHR::e2RayTracingShader: return "2RayTracingShader"; - case PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt: return "2FragmentDensityProcessExt"; - case PipelineStageFlagBits2KHR::e2TaskShaderNv: return "2TaskShaderNv"; - case PipelineStageFlagBits2KHR::e2MeshShaderNv: return "2MeshShaderNv"; + case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt"; + case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt"; + case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv"; + case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; + case PipelineStageFlagBits2KHR::eAccelerationStructureBuild: return "AccelerationStructureBuild"; + case PipelineStageFlagBits2KHR::eRayTracingShader: return "RayTracingShader"; + case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt: return "FragmentDensityProcessExt"; + case PipelineStageFlagBits2KHR::eTaskShaderNv: return "TaskShaderNv"; + case PipelineStageFlagBits2KHR::eMeshShaderNv: return "MeshShaderNv"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -10859,6 +10897,7 @@ namespace VULKAN_HPP_NAMESPACE , eImportSemaphoreZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA , eSemaphoreGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA #endif /*VK_USE_PLATFORM_FUCHSIA*/ + , ePhysicalDeviceExtendedDynamicState2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT #if defined( VK_USE_PLATFORM_SCREEN_QNX ) , eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ @@ -11708,6 +11747,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA: return "ImportSemaphoreZirconHandleInfoFUCHSIA"; case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA: return "SemaphoreGetZirconHandleInfoFUCHSIA"; #endif /*VK_USE_PLATFORM_FUCHSIA*/ + case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT: + return "PhysicalDeviceExtendedDynamicState2FeaturesEXT"; #if defined( VK_USE_PLATFORM_SCREEN_QNX ) case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX"; #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ @@ -12216,9 +12257,10 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT { - eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT, - eLineInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT, - eSeparateInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT + eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT, + eVkVideoDecodeH264FieldLayoutLineInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT, + eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane = + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagBitsEXT value ) @@ -12227,8 +12269,10 @@ namespace VULKAN_HPP_NAMESPACE { case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly: return "VkVideoDecodeH264ProgressivePicturesOnly"; - case VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane: return "LineInterlacedPlane"; - case VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane: return "SeparateInterlacedPlane"; + case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane: + return "VkVideoDecodeH264FieldLayoutLineInterlacedPlane"; + case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane: + return "VkVideoDecodeH264FieldLayoutSeparateInterlacedPlane"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -12308,16 +12352,17 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) enum class VideoEncodeH264CreateFlagBitsEXT : VkVideoEncodeH264CreateFlagsEXT { - eDefault = VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT, - eReserved0 = VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT + eVkVideoEncodeH264CreateDefault = VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT, + eVkVideoEncodeH264CreateReserved0 = VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CreateFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH264CreateFlagBitsEXT::eDefault: return "Default"; - case VideoEncodeH264CreateFlagBitsEXT::eReserved0: return "Reserved0"; + case VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateDefault: return "VkVideoEncodeH264CreateDefault"; + case VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0: + return "VkVideoEncodeH264CreateReserved0"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -12326,18 +12371,21 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) enum class VideoEncodeH264InputModeFlagBitsEXT : VkVideoEncodeH264InputModeFlagsEXT { - eFrame = VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT, - eSlice = VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT, - eNonVcl = VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT + eVkVideoEncodeH264InputModeFrame = VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT, + eVkVideoEncodeH264InputModeSlice = VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT, + eVkVideoEncodeH264InputModeNonVcl = VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264InputModeFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH264InputModeFlagBitsEXT::eFrame: return "Frame"; - case VideoEncodeH264InputModeFlagBitsEXT::eSlice: return "Slice"; - case VideoEncodeH264InputModeFlagBitsEXT::eNonVcl: return "NonVcl"; + case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame: + return "VkVideoEncodeH264InputModeFrame"; + case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice: + return "VkVideoEncodeH264InputModeSlice"; + case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl: + return "VkVideoEncodeH264InputModeNonVcl"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -12346,18 +12394,21 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) enum class VideoEncodeH264OutputModeFlagBitsEXT : VkVideoEncodeH264OutputModeFlagsEXT { - eFrame = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT, - eSlice = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT, - eNonVcl = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT + eVkVideoEncodeH264OutputModeFrame = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT, + eVkVideoEncodeH264OutputModeSlice = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT, + eVkVideoEncodeH264OutputModeNonVcl = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264OutputModeFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH264OutputModeFlagBitsEXT::eFrame: return "Frame"; - case VideoEncodeH264OutputModeFlagBitsEXT::eSlice: return "Slice"; - case VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl: return "NonVcl"; + case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame: + return "VkVideoEncodeH264OutputModeFrame"; + case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice: + return "VkVideoEncodeH264OutputModeSlice"; + case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl: + return "VkVideoEncodeH264OutputModeNonVcl"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; } } @@ -12657,34 +12708,32 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags64 { allFlags = - VkFlags64( AccessFlagBits2KHR::e2None ) | VkFlags64( AccessFlagBits2KHR::e2IndirectCommandRead ) | - VkFlags64( AccessFlagBits2KHR::e2IndexRead ) | VkFlags64( AccessFlagBits2KHR::e2VertexAttributeRead ) | - VkFlags64( AccessFlagBits2KHR::e2UniformRead ) | VkFlags64( AccessFlagBits2KHR::e2InputAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderWrite ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentWrite ) | - VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) | - VkFlags64( AccessFlagBits2KHR::e2TransferRead ) | VkFlags64( AccessFlagBits2KHR::e2TransferWrite ) | - VkFlags64( AccessFlagBits2KHR::e2HostRead ) | VkFlags64( AccessFlagBits2KHR::e2HostWrite ) | - VkFlags64( AccessFlagBits2KHR::e2MemoryRead ) | VkFlags64( AccessFlagBits2KHR::e2MemoryWrite ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderSampledRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderStorageRead ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderStorageWrite ) + VkFlags64( AccessFlagBits2KHR::eNone ) | VkFlags64( AccessFlagBits2KHR::eIndirectCommandRead ) | + VkFlags64( AccessFlagBits2KHR::eIndexRead ) | VkFlags64( AccessFlagBits2KHR::eVertexAttributeRead ) | + VkFlags64( AccessFlagBits2KHR::eUniformRead ) | VkFlags64( AccessFlagBits2KHR::eInputAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eShaderRead ) | VkFlags64( AccessFlagBits2KHR::eShaderWrite ) | + VkFlags64( AccessFlagBits2KHR::eColorAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentWrite ) | + VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eTransferRead ) | + VkFlags64( AccessFlagBits2KHR::eTransferWrite ) | VkFlags64( AccessFlagBits2KHR::eHostRead ) | + VkFlags64( AccessFlagBits2KHR::eHostWrite ) | VkFlags64( AccessFlagBits2KHR::eMemoryRead ) | + VkFlags64( AccessFlagBits2KHR::eMemoryWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderSampledRead ) | + VkFlags64( AccessFlagBits2KHR::eShaderStorageRead ) | VkFlags64( AccessFlagBits2KHR::eShaderStorageWrite ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( AccessFlagBits2KHR::e2VideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::e2VideoDecodeWrite ) | - VkFlags64( AccessFlagBits2KHR::e2VideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::e2VideoEncodeWrite ) + | VkFlags64( AccessFlagBits2KHR::eVideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoDecodeWrite ) | + VkFlags64( AccessFlagBits2KHR::eVideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoEncodeWrite ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) | - VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) | - VkFlags64( AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessReadNv ) | - VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) | - VkFlags64( AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureRead ) | - VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureWrite ) | - VkFlags64( AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt ) + | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) | + VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) | + VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) | + VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) | + VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) | + VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) | + VkFlags64( AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eAccelerationStructureRead ) | + VkFlags64( AccessFlagBits2KHR::eAccelerationStructureWrite ) | + VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadExt ) | + VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt ) }; }; @@ -12717,84 +12766,84 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & AccessFlagBits2KHR::e2IndirectCommandRead ) - result += "2IndirectCommandRead | "; - if ( value & AccessFlagBits2KHR::e2IndexRead ) - result += "2IndexRead | "; - if ( value & AccessFlagBits2KHR::e2VertexAttributeRead ) - result += "2VertexAttributeRead | "; - if ( value & AccessFlagBits2KHR::e2UniformRead ) - result += "2UniformRead | "; - if ( value & AccessFlagBits2KHR::e2InputAttachmentRead ) - result += "2InputAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderRead ) - result += "2ShaderRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderWrite ) - result += "2ShaderWrite | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentRead ) - result += "2ColorAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentWrite ) - result += "2ColorAttachmentWrite | "; - if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) - result += "2DepthStencilAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) - result += "2DepthStencilAttachmentWrite | "; - if ( value & AccessFlagBits2KHR::e2TransferRead ) - result += "2TransferRead | "; - if ( value & AccessFlagBits2KHR::e2TransferWrite ) - result += "2TransferWrite | "; - if ( value & AccessFlagBits2KHR::e2HostRead ) - result += "2HostRead | "; - if ( value & AccessFlagBits2KHR::e2HostWrite ) - result += "2HostWrite | "; - if ( value & AccessFlagBits2KHR::e2MemoryRead ) - result += "2MemoryRead | "; - if ( value & AccessFlagBits2KHR::e2MemoryWrite ) - result += "2MemoryWrite | "; - if ( value & AccessFlagBits2KHR::e2ShaderSampledRead ) - result += "2ShaderSampledRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderStorageRead ) - result += "2ShaderStorageRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderStorageWrite ) - result += "2ShaderStorageWrite | "; + if ( value & AccessFlagBits2KHR::eIndirectCommandRead ) + result += "IndirectCommandRead | "; + if ( value & AccessFlagBits2KHR::eIndexRead ) + result += "IndexRead | "; + if ( value & AccessFlagBits2KHR::eVertexAttributeRead ) + result += "VertexAttributeRead | "; + if ( value & AccessFlagBits2KHR::eUniformRead ) + result += "UniformRead | "; + if ( value & AccessFlagBits2KHR::eInputAttachmentRead ) + result += "InputAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eShaderRead ) + result += "ShaderRead | "; + if ( value & AccessFlagBits2KHR::eShaderWrite ) + result += "ShaderWrite | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentRead ) + result += "ColorAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentWrite ) + result += "ColorAttachmentWrite | "; + if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentRead ) + result += "DepthStencilAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) + result += "DepthStencilAttachmentWrite | "; + if ( value & AccessFlagBits2KHR::eTransferRead ) + result += "TransferRead | "; + if ( value & AccessFlagBits2KHR::eTransferWrite ) + result += "TransferWrite | "; + if ( value & AccessFlagBits2KHR::eHostRead ) + result += "HostRead | "; + if ( value & AccessFlagBits2KHR::eHostWrite ) + result += "HostWrite | "; + if ( value & AccessFlagBits2KHR::eMemoryRead ) + result += "MemoryRead | "; + if ( value & AccessFlagBits2KHR::eMemoryWrite ) + result += "MemoryWrite | "; + if ( value & AccessFlagBits2KHR::eShaderSampledRead ) + result += "ShaderSampledRead | "; + if ( value & AccessFlagBits2KHR::eShaderStorageRead ) + result += "ShaderStorageRead | "; + if ( value & AccessFlagBits2KHR::eShaderStorageWrite ) + result += "ShaderStorageWrite | "; #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & AccessFlagBits2KHR::e2VideoDecodeRead ) - result += "2VideoDecodeRead | "; + if ( value & AccessFlagBits2KHR::eVideoDecodeRead ) + result += "VideoDecodeRead | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & AccessFlagBits2KHR::e2VideoDecodeWrite ) - result += "2VideoDecodeWrite | "; + if ( value & AccessFlagBits2KHR::eVideoDecodeWrite ) + result += "VideoDecodeWrite | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & AccessFlagBits2KHR::e2VideoEncodeRead ) - result += "2VideoEncodeRead | "; + if ( value & AccessFlagBits2KHR::eVideoEncodeRead ) + result += "VideoEncodeRead | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & AccessFlagBits2KHR::e2VideoEncodeWrite ) - result += "2VideoEncodeWrite | "; + if ( value & AccessFlagBits2KHR::eVideoEncodeWrite ) + result += "VideoEncodeWrite | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) - result += "2TransformFeedbackWriteExt | "; - if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) - result += "2TransformFeedbackCounterReadExt | "; - if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) - result += "2TransformFeedbackCounterWriteExt | "; - if ( value & AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) - result += "2ConditionalRenderingReadExt | "; - if ( value & AccessFlagBits2KHR::e2CommandPreprocessReadNv ) - result += "2CommandPreprocessReadNv | "; - if ( value & AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) - result += "2CommandPreprocessWriteNv | "; - if ( value & AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) - result += "2FragmentShadingRateAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2AccelerationStructureRead ) - result += "2AccelerationStructureRead | "; - if ( value & AccessFlagBits2KHR::e2AccelerationStructureWrite ) - result += "2AccelerationStructureWrite | "; - if ( value & AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) - result += "2FragmentDensityMapReadExt | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt ) - result += "2ColorAttachmentReadNoncoherentExt | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteExt ) + result += "TransformFeedbackWriteExt | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) + result += "TransformFeedbackCounterReadExt | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) + result += "TransformFeedbackCounterWriteExt | "; + if ( value & AccessFlagBits2KHR::eConditionalRenderingReadExt ) + result += "ConditionalRenderingReadExt | "; + if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNv ) + result += "CommandPreprocessReadNv | "; + if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNv ) + result += "CommandPreprocessWriteNv | "; + if ( value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) + result += "FragmentShadingRateAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eAccelerationStructureRead ) + result += "AccelerationStructureRead | "; + if ( value & AccessFlagBits2KHR::eAccelerationStructureWrite ) + result += "AccelerationStructureWrite | "; + if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadExt ) + result += "FragmentDensityMapReadExt | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt ) + result += "ColorAttachmentReadNoncoherentExt | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -16512,35 +16561,35 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags64 { allFlags = - VkFlags64( PipelineStageFlagBits2KHR::e2None ) | VkFlags64( PipelineStageFlagBits2KHR::e2TopOfPipe ) | - VkFlags64( PipelineStageFlagBits2KHR::e2DrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::e2VertexInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2VertexShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TessellationControlShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2GeometryShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) | - VkFlags64( PipelineStageFlagBits2KHR::e2LateFragmentTests ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ComputeShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AllTransfer ) | VkFlags64( PipelineStageFlagBits2KHR::e2BottomOfPipe ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Host ) | VkFlags64( PipelineStageFlagBits2KHR::e2AllGraphics ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AllCommands ) | VkFlags64( PipelineStageFlagBits2KHR::e2Copy ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Resolve ) | VkFlags64( PipelineStageFlagBits2KHR::e2Blit ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Clear ) | VkFlags64( PipelineStageFlagBits2KHR::e2IndexInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2VertexAttributeInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) + VkFlags64( PipelineStageFlagBits2KHR::eNone ) | VkFlags64( PipelineStageFlagBits2KHR::eTopOfPipe ) | + VkFlags64( PipelineStageFlagBits2KHR::eDrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexInput ) | + VkFlags64( PipelineStageFlagBits2KHR::eVertexShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eTessellationControlShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eGeometryShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eEarlyFragmentTests ) | + VkFlags64( PipelineStageFlagBits2KHR::eLateFragmentTests ) | + VkFlags64( PipelineStageFlagBits2KHR::eColorAttachmentOutput ) | + VkFlags64( PipelineStageFlagBits2KHR::eComputeShader ) | VkFlags64( PipelineStageFlagBits2KHR::eAllTransfer ) | + VkFlags64( PipelineStageFlagBits2KHR::eBottomOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eHost ) | + VkFlags64( PipelineStageFlagBits2KHR::eAllGraphics ) | VkFlags64( PipelineStageFlagBits2KHR::eAllCommands ) | + VkFlags64( PipelineStageFlagBits2KHR::eCopy ) | VkFlags64( PipelineStageFlagBits2KHR::eResolve ) | + VkFlags64( PipelineStageFlagBits2KHR::eBlit ) | VkFlags64( PipelineStageFlagBits2KHR::eClear ) | + VkFlags64( PipelineStageFlagBits2KHR::eIndexInput ) | + VkFlags64( PipelineStageFlagBits2KHR::eVertexAttributeInput ) | + VkFlags64( PipelineStageFlagBits2KHR::ePreRasterizationShaders ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( PipelineStageFlagBits2KHR::e2VideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::e2VideoEncode ) + | VkFlags64( PipelineStageFlagBits2KHR::eVideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::eVideoEncode ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) | - VkFlags64( PipelineStageFlagBits2KHR::e2RayTracingShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::e2MeshShaderNv ) + | VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) | + VkFlags64( PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) | + VkFlags64( PipelineStageFlagBits2KHR::eRayTracingShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNv ) }; }; @@ -16574,80 +16623,80 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & PipelineStageFlagBits2KHR::e2TopOfPipe ) - result += "2TopOfPipe | "; - if ( value & PipelineStageFlagBits2KHR::e2DrawIndirect ) - result += "2DrawIndirect | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexInput ) - result += "2VertexInput | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexShader ) - result += "2VertexShader | "; - if ( value & PipelineStageFlagBits2KHR::e2TessellationControlShader ) - result += "2TessellationControlShader | "; - if ( value & PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) - result += "2TessellationEvaluationShader | "; - if ( value & PipelineStageFlagBits2KHR::e2GeometryShader ) - result += "2GeometryShader | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentShader ) - result += "2FragmentShader | "; - if ( value & PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) - result += "2EarlyFragmentTests | "; - if ( value & PipelineStageFlagBits2KHR::e2LateFragmentTests ) - result += "2LateFragmentTests | "; - if ( value & PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) - result += "2ColorAttachmentOutput | "; - if ( value & PipelineStageFlagBits2KHR::e2ComputeShader ) - result += "2ComputeShader | "; - if ( value & PipelineStageFlagBits2KHR::e2AllTransfer ) - result += "2AllTransfer | "; - if ( value & PipelineStageFlagBits2KHR::e2BottomOfPipe ) - result += "2BottomOfPipe | "; - if ( value & PipelineStageFlagBits2KHR::e2Host ) - result += "2Host | "; - if ( value & PipelineStageFlagBits2KHR::e2AllGraphics ) - result += "2AllGraphics | "; - if ( value & PipelineStageFlagBits2KHR::e2AllCommands ) - result += "2AllCommands | "; - if ( value & PipelineStageFlagBits2KHR::e2Copy ) - result += "2Copy | "; - if ( value & PipelineStageFlagBits2KHR::e2Resolve ) - result += "2Resolve | "; - if ( value & PipelineStageFlagBits2KHR::e2Blit ) - result += "2Blit | "; - if ( value & PipelineStageFlagBits2KHR::e2Clear ) - result += "2Clear | "; - if ( value & PipelineStageFlagBits2KHR::e2IndexInput ) - result += "2IndexInput | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexAttributeInput ) - result += "2VertexAttributeInput | "; - if ( value & PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) - result += "2PreRasterizationShaders | "; + if ( value & PipelineStageFlagBits2KHR::eTopOfPipe ) + result += "TopOfPipe | "; + if ( value & PipelineStageFlagBits2KHR::eDrawIndirect ) + result += "DrawIndirect | "; + if ( value & PipelineStageFlagBits2KHR::eVertexInput ) + result += "VertexInput | "; + if ( value & PipelineStageFlagBits2KHR::eVertexShader ) + result += "VertexShader | "; + if ( value & PipelineStageFlagBits2KHR::eTessellationControlShader ) + result += "TessellationControlShader | "; + if ( value & PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) + result += "TessellationEvaluationShader | "; + if ( value & PipelineStageFlagBits2KHR::eGeometryShader ) + result += "GeometryShader | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentShader ) + result += "FragmentShader | "; + if ( value & PipelineStageFlagBits2KHR::eEarlyFragmentTests ) + result += "EarlyFragmentTests | "; + if ( value & PipelineStageFlagBits2KHR::eLateFragmentTests ) + result += "LateFragmentTests | "; + if ( value & PipelineStageFlagBits2KHR::eColorAttachmentOutput ) + result += "ColorAttachmentOutput | "; + if ( value & PipelineStageFlagBits2KHR::eComputeShader ) + result += "ComputeShader | "; + if ( value & PipelineStageFlagBits2KHR::eAllTransfer ) + result += "AllTransfer | "; + if ( value & PipelineStageFlagBits2KHR::eBottomOfPipe ) + result += "BottomOfPipe | "; + if ( value & PipelineStageFlagBits2KHR::eHost ) + result += "Host | "; + if ( value & PipelineStageFlagBits2KHR::eAllGraphics ) + result += "AllGraphics | "; + if ( value & PipelineStageFlagBits2KHR::eAllCommands ) + result += "AllCommands | "; + if ( value & PipelineStageFlagBits2KHR::eCopy ) + result += "Copy | "; + if ( value & PipelineStageFlagBits2KHR::eResolve ) + result += "Resolve | "; + if ( value & PipelineStageFlagBits2KHR::eBlit ) + result += "Blit | "; + if ( value & PipelineStageFlagBits2KHR::eClear ) + result += "Clear | "; + if ( value & PipelineStageFlagBits2KHR::eIndexInput ) + result += "IndexInput | "; + if ( value & PipelineStageFlagBits2KHR::eVertexAttributeInput ) + result += "VertexAttributeInput | "; + if ( value & PipelineStageFlagBits2KHR::ePreRasterizationShaders ) + result += "PreRasterizationShaders | "; #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & PipelineStageFlagBits2KHR::e2VideoDecode ) - result += "2VideoDecode | "; + if ( value & PipelineStageFlagBits2KHR::eVideoDecode ) + result += "VideoDecode | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & PipelineStageFlagBits2KHR::e2VideoEncode ) - result += "2VideoEncode | "; + if ( value & PipelineStageFlagBits2KHR::eVideoEncode ) + result += "VideoEncode | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) - result += "2TransformFeedbackExt | "; - if ( value & PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) - result += "2ConditionalRenderingExt | "; - if ( value & PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) - result += "2CommandPreprocessNv | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) - result += "2FragmentShadingRateAttachment | "; - if ( value & PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) - result += "2AccelerationStructureBuild | "; - if ( value & PipelineStageFlagBits2KHR::e2RayTracingShader ) - result += "2RayTracingShader | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) - result += "2FragmentDensityProcessExt | "; - if ( value & PipelineStageFlagBits2KHR::e2TaskShaderNv ) - result += "2TaskShaderNv | "; - if ( value & PipelineStageFlagBits2KHR::e2MeshShaderNv ) - result += "2MeshShaderNv | "; + if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt ) + result += "TransformFeedbackExt | "; + if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt ) + result += "ConditionalRenderingExt | "; + if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv ) + result += "CommandPreprocessNv | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) + result += "FragmentShadingRateAttachment | "; + if ( value & PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) + result += "AccelerationStructureBuild | "; + if ( value & PipelineStageFlagBits2KHR::eRayTracingShader ) + result += "RayTracingShader | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) + result += "FragmentDensityProcessExt | "; + if ( value & PipelineStageFlagBits2KHR::eTaskShaderNv ) + result += "TaskShaderNv | "; + if ( value & PipelineStageFlagBits2KHR::eMeshShaderNv ) + result += "MeshShaderNv | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -18425,8 +18474,8 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags { allFlags = VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly ) | - VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) | - VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane ) + VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane ) | + VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane ) }; }; @@ -18460,10 +18509,10 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) - result += "LineInterlacedPlane | "; - if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane ) - result += "SeparateInterlacedPlane | "; + if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane ) + result += "VkVideoDecodeH264FieldLayoutLineInterlacedPlane | "; + if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane ) + result += "VkVideoDecodeH264FieldLayoutSeparateInterlacedPlane | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -18624,8 +18673,8 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = - VkFlags( VideoEncodeH264CreateFlagBitsEXT::eDefault ) | VkFlags( VideoEncodeH264CreateFlagBitsEXT::eReserved0 ) + allFlags = VkFlags( VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateDefault ) | + VkFlags( VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0 ) }; }; @@ -18659,8 +18708,8 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH264CreateFlagBitsEXT::eReserved0 ) - result += "Reserved0 | "; + if ( value & VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0 ) + result += "VkVideoEncodeH264CreateReserved0 | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -18674,9 +18723,9 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eFrame ) | - VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eSlice ) | - VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eNonVcl ) + allFlags = VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame ) | + VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice ) | + VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl ) }; }; @@ -18710,12 +18759,12 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH264InputModeFlagBitsEXT::eFrame ) - result += "Frame | "; - if ( value & VideoEncodeH264InputModeFlagBitsEXT::eSlice ) - result += "Slice | "; - if ( value & VideoEncodeH264InputModeFlagBitsEXT::eNonVcl ) - result += "NonVcl | "; + if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame ) + result += "VkVideoEncodeH264InputModeFrame | "; + if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice ) + result += "VkVideoEncodeH264InputModeSlice | "; + if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl ) + result += "VkVideoEncodeH264InputModeNonVcl | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -18729,9 +18778,9 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eFrame ) | - VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eSlice ) | - VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl ) + allFlags = VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame ) | + VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice ) | + VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl ) }; }; @@ -18765,12 +18814,12 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eFrame ) - result += "Frame | "; - if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eSlice ) - result += "Slice | "; - if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl ) - result += "NonVcl | "; + if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame ) + result += "VkVideoEncodeH264OutputModeFrame | "; + if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice ) + result += "VkVideoEncodeH264OutputModeSlice | "; + if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl ) + result += "VkVideoEncodeH264OutputModeNonVcl | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -19827,13 +19876,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR; public: - VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT : m_accelerationStructureKHR( VK_NULL_HANDLE ) - {} - - VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_accelerationStructureKHR( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default; + VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureKHR( accelerationStructureKHR ) @@ -19849,7 +19893,7 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_accelerationStructureKHR = VK_NULL_HANDLE; + m_accelerationStructureKHR = {}; return *this; } @@ -19888,7 +19932,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkAccelerationStructureKHR m_accelerationStructureKHR; + VkAccelerationStructureKHR m_accelerationStructureKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), "handle and wrapper have different size!" ); @@ -20892,10 +20936,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; public: - VULKAN_HPP_CONSTEXPR Buffer() VULKAN_HPP_NOEXCEPT : m_buffer( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_buffer( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Buffer() = default; + VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -20908,7 +20950,7 @@ namespace VULKAN_HPP_NAMESPACE Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_buffer = VK_NULL_HANDLE; + m_buffer = {}; return *this; } @@ -20947,7 +20989,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkBuffer m_buffer; + VkBuffer m_buffer = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); @@ -22062,12 +22104,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV; public: - VULKAN_HPP_CONSTEXPR AccelerationStructureNV() VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_accelerationStructureNV( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default; + VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( accelerationStructureNV ) @@ -22083,7 +22121,7 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_accelerationStructureNV = VK_NULL_HANDLE; + m_accelerationStructureNV = {}; return *this; } @@ -22122,7 +22160,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkAccelerationStructureNV m_accelerationStructureNV; + VkAccelerationStructureNV m_accelerationStructureNV = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" ); @@ -22344,10 +22382,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; public: - VULKAN_HPP_CONSTEXPR SwapchainKHR() VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR SwapchainKHR() = default; + VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {} @@ -22362,7 +22398,7 @@ namespace VULKAN_HPP_NAMESPACE SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_swapchainKHR = VK_NULL_HANDLE; + m_swapchainKHR = {}; return *this; } @@ -22401,7 +22437,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkSwapchainKHR m_swapchainKHR; + VkSwapchainKHR m_swapchainKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); @@ -22443,10 +22479,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; public: - VULKAN_HPP_CONSTEXPR Semaphore() VULKAN_HPP_NOEXCEPT : m_semaphore( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_semaphore( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Semaphore() = default; + VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -22459,7 +22493,7 @@ namespace VULKAN_HPP_NAMESPACE Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_semaphore = VK_NULL_HANDLE; + m_semaphore = {}; return *this; } @@ -22498,7 +22532,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkSemaphore m_semaphore; + VkSemaphore m_semaphore = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); @@ -22540,10 +22574,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; public: - VULKAN_HPP_CONSTEXPR Fence() VULKAN_HPP_NOEXCEPT : m_fence( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_fence( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Fence() = default; + VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -22556,7 +22588,7 @@ namespace VULKAN_HPP_NAMESPACE Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_fence = VK_NULL_HANDLE; + m_fence = {}; return *this; } @@ -22595,7 +22627,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkFence m_fence; + VkFence m_fence = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); @@ -24594,10 +24626,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; public: - VULKAN_HPP_CONSTEXPR DeviceMemory() VULKAN_HPP_NOEXCEPT : m_deviceMemory( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR DeviceMemory() = default; + VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {} @@ -24612,7 +24642,7 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_deviceMemory = VK_NULL_HANDLE; + m_deviceMemory = {}; return *this; } @@ -24651,7 +24681,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDeviceMemory m_deviceMemory; + VkDeviceMemory m_deviceMemory = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); @@ -25320,10 +25350,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; public: - VULKAN_HPP_CONSTEXPR Image() VULKAN_HPP_NOEXCEPT : m_image( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_image( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Image() = default; + VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -25336,7 +25364,7 @@ namespace VULKAN_HPP_NAMESPACE Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_image = VK_NULL_HANDLE; + m_image = {}; return *this; } @@ -25375,7 +25403,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkImage m_image; + VkImage m_image = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); @@ -29249,10 +29277,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; public: - VULKAN_HPP_CONSTEXPR CommandPool() VULKAN_HPP_NOEXCEPT : m_commandPool( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_commandPool( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR CommandPool() = default; + VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {} @@ -29267,7 +29293,7 @@ namespace VULKAN_HPP_NAMESPACE CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_commandPool = VK_NULL_HANDLE; + m_commandPool = {}; return *this; } @@ -29306,7 +29332,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkCommandPool m_commandPool; + VkCommandPool m_commandPool = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); @@ -29447,10 +29473,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; public: - VULKAN_HPP_CONSTEXPR RenderPass() VULKAN_HPP_NOEXCEPT : m_renderPass( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_renderPass( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR RenderPass() = default; + VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {} @@ -29464,7 +29488,7 @@ namespace VULKAN_HPP_NAMESPACE RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_renderPass = VK_NULL_HANDLE; + m_renderPass = {}; return *this; } @@ -29503,7 +29527,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkRenderPass m_renderPass; + VkRenderPass m_renderPass = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); @@ -29545,10 +29569,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; public: - VULKAN_HPP_CONSTEXPR Framebuffer() VULKAN_HPP_NOEXCEPT : m_framebuffer( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_framebuffer( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Framebuffer() = default; + VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {} @@ -29563,7 +29585,7 @@ namespace VULKAN_HPP_NAMESPACE Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_framebuffer = VK_NULL_HANDLE; + m_framebuffer = {}; return *this; } @@ -29602,7 +29624,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkFramebuffer m_framebuffer; + VkFramebuffer m_framebuffer = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); @@ -30448,10 +30470,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; public: - VULKAN_HPP_CONSTEXPR QueryPool() VULKAN_HPP_NOEXCEPT : m_queryPool( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_queryPool( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR QueryPool() = default; + VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -30464,7 +30484,7 @@ namespace VULKAN_HPP_NAMESPACE QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_queryPool = VK_NULL_HANDLE; + m_queryPool = {}; return *this; } @@ -30503,7 +30523,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkQueryPool m_queryPool; + VkQueryPool m_queryPool = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); @@ -30765,10 +30785,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR VideoSessionKHR() VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default; + VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {} @@ -30783,7 +30801,7 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_videoSessionKHR = VK_NULL_HANDLE; + m_videoSessionKHR = {}; return *this; } @@ -30822,7 +30840,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkVideoSessionKHR m_videoSessionKHR; + VkVideoSessionKHR m_videoSessionKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ), "handle and wrapper have different size!" ); @@ -30859,13 +30877,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT : m_videoSessionParametersKHR( VK_NULL_HANDLE ) - {} - - VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_videoSessionParametersKHR( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default; + VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionParametersKHR( videoSessionParametersKHR ) @@ -30881,7 +30894,7 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_videoSessionParametersKHR = VK_NULL_HANDLE; + m_videoSessionParametersKHR = {}; return *this; } @@ -30920,7 +30933,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkVideoSessionParametersKHR m_videoSessionParametersKHR; + VkVideoSessionParametersKHR m_videoSessionParametersKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ), "handle and wrapper have different size!" ); @@ -30956,10 +30969,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; public: - VULKAN_HPP_CONSTEXPR ImageView() VULKAN_HPP_NOEXCEPT : m_imageView( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_imageView( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR ImageView() = default; + VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -30972,7 +30983,7 @@ namespace VULKAN_HPP_NAMESPACE ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_imageView = VK_NULL_HANDLE; + m_imageView = {}; return *this; } @@ -31011,7 +31022,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkImageView m_imageView; + VkImageView m_imageView = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); @@ -31413,10 +31424,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; public: - VULKAN_HPP_CONSTEXPR PipelineLayout() VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR PipelineLayout() = default; + VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {} @@ -31431,7 +31440,7 @@ namespace VULKAN_HPP_NAMESPACE PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_pipelineLayout = VK_NULL_HANDLE; + m_pipelineLayout = {}; return *this; } @@ -31470,7 +31479,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPipelineLayout m_pipelineLayout; + VkPipelineLayout m_pipelineLayout = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); @@ -31512,10 +31521,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; public: - VULKAN_HPP_CONSTEXPR DescriptorSet() VULKAN_HPP_NOEXCEPT : m_descriptorSet( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR DescriptorSet() = default; + VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {} @@ -31530,7 +31537,7 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_descriptorSet = VK_NULL_HANDLE; + m_descriptorSet = {}; return *this; } @@ -31569,7 +31576,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDescriptorSet m_descriptorSet; + VkDescriptorSet m_descriptorSet = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); @@ -31611,10 +31618,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; public: - VULKAN_HPP_CONSTEXPR Pipeline() VULKAN_HPP_NOEXCEPT : m_pipeline( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipeline( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Pipeline() = default; + VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -31627,7 +31632,7 @@ namespace VULKAN_HPP_NAMESPACE Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_pipeline = VK_NULL_HANDLE; + m_pipeline = {}; return *this; } @@ -31666,7 +31671,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPipeline m_pipeline; + VkPipeline m_pipeline = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); @@ -33696,13 +33701,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT : m_indirectCommandsLayoutNV( VK_NULL_HANDLE ) - {} - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_indirectCommandsLayoutNV( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default; + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV ) @@ -33718,7 +33718,7 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_indirectCommandsLayoutNV = VK_NULL_HANDLE; + m_indirectCommandsLayoutNV = {}; return *this; } @@ -33757,7 +33757,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV; + VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), "handle and wrapper have different size!" ); @@ -34806,10 +34806,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; public: - VULKAN_HPP_CONSTEXPR Sampler() VULKAN_HPP_NOEXCEPT : m_sampler( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_sampler( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Sampler() = default; + VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -34822,7 +34820,7 @@ namespace VULKAN_HPP_NAMESPACE Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_sampler = VK_NULL_HANDLE; + m_sampler = {}; return *this; } @@ -34861,7 +34859,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkSampler m_sampler; + VkSampler m_sampler = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); @@ -35059,10 +35057,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; public: - VULKAN_HPP_CONSTEXPR BufferView() VULKAN_HPP_NOEXCEPT : m_bufferView( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_bufferView( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR BufferView() = default; + VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {} @@ -35076,7 +35072,7 @@ namespace VULKAN_HPP_NAMESPACE BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_bufferView = VK_NULL_HANDLE; + m_bufferView = {}; return *this; } @@ -35115,7 +35111,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkBufferView m_bufferView; + VkBufferView m_bufferView = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); @@ -35373,13 +35369,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; public: - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT : m_descriptorUpdateTemplate( VK_NULL_HANDLE ) - {} - - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_descriptorUpdateTemplate( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default; + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT : m_descriptorUpdateTemplate( descriptorUpdateTemplate ) @@ -35395,7 +35386,7 @@ namespace VULKAN_HPP_NAMESPACE DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_descriptorUpdateTemplate = VK_NULL_HANDLE; + m_descriptorUpdateTemplate = {}; return *this; } @@ -35434,7 +35425,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; + VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); @@ -35477,10 +35468,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; public: - VULKAN_HPP_CONSTEXPR Event() VULKAN_HPP_NOEXCEPT : m_event( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_event( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Event() = default; + VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -35493,7 +35482,7 @@ namespace VULKAN_HPP_NAMESPACE Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_event = VK_NULL_HANDLE; + m_event = {}; return *this; } @@ -35532,7 +35521,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkEvent m_event; + VkEvent m_event = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); @@ -36658,10 +36647,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; public: - VULKAN_HPP_CONSTEXPR CommandBuffer() VULKAN_HPP_NOEXCEPT : m_commandBuffer( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR CommandBuffer() = default; + VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {} @@ -36676,7 +36663,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_commandBuffer = VK_NULL_HANDLE; + m_commandBuffer = {}; return *this; } @@ -37690,6 +37677,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; @@ -37795,6 +37786,15 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + void + setPatchControlPointsEXT( uint32_t patchControlPoints, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; @@ -37828,11 +37828,21 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; + + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; + + template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; @@ -38168,7 +38178,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkCommandBuffer m_commandBuffer; + VkCommandBuffer m_commandBuffer = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); @@ -38387,10 +38397,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; public: - VULKAN_HPP_CONSTEXPR ShaderModule() VULKAN_HPP_NOEXCEPT : m_shaderModule( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_shaderModule( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR ShaderModule() = default; + VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {} @@ -38405,7 +38413,7 @@ namespace VULKAN_HPP_NAMESPACE ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_shaderModule = VK_NULL_HANDLE; + m_shaderModule = {}; return *this; } @@ -38444,7 +38452,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkShaderModule m_shaderModule; + VkShaderModule m_shaderModule = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); @@ -40999,10 +41007,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; public: - VULKAN_HPP_CONSTEXPR DescriptorPool() VULKAN_HPP_NOEXCEPT : m_descriptorPool( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR DescriptorPool() = default; + VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {} @@ -41017,7 +41023,7 @@ namespace VULKAN_HPP_NAMESPACE DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_descriptorPool = VK_NULL_HANDLE; + m_descriptorPool = {}; return *this; } @@ -41056,7 +41062,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDescriptorPool m_descriptorPool; + VkDescriptorPool m_descriptorPool = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); @@ -41098,12 +41104,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; public: - VULKAN_HPP_CONSTEXPR DescriptorSetLayout() VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_descriptorSetLayout( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default; + VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( descriptorSetLayout ) {} @@ -41118,7 +41120,7 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_descriptorSetLayout = VK_NULL_HANDLE; + m_descriptorSetLayout = {}; return *this; } @@ -41157,7 +41159,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDescriptorSetLayout m_descriptorSetLayout; + VkDescriptorSetLayout m_descriptorSetLayout = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); @@ -43631,10 +43633,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; public: - VULKAN_HPP_CONSTEXPR DisplayKHR() VULKAN_HPP_NOEXCEPT : m_displayKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_displayKHR( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR DisplayKHR() = default; + VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {} @@ -43648,7 +43648,7 @@ namespace VULKAN_HPP_NAMESPACE DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_displayKHR = VK_NULL_HANDLE; + m_displayKHR = {}; return *this; } @@ -43687,7 +43687,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDisplayKHR m_displayKHR; + VkDisplayKHR m_displayKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); @@ -43817,14 +43817,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT - : m_performanceConfigurationINTEL( VK_NULL_HANDLE ) - {} - - VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_performanceConfigurationINTEL( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default; + VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT : m_performanceConfigurationINTEL( performanceConfigurationINTEL ) @@ -43841,7 +43835,7 @@ namespace VULKAN_HPP_NAMESPACE PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_performanceConfigurationINTEL = VK_NULL_HANDLE; + m_performanceConfigurationINTEL = {}; return *this; } @@ -43880,7 +43874,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL; + VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), @@ -44110,12 +44104,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR DeferredOperationKHR() VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_deferredOperationKHR( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default; + VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( deferredOperationKHR ) {} @@ -44130,7 +44120,7 @@ namespace VULKAN_HPP_NAMESPACE DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_deferredOperationKHR = VK_NULL_HANDLE; + m_deferredOperationKHR = {}; return *this; } @@ -44169,7 +44159,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDeferredOperationKHR m_deferredOperationKHR; + VkDeferredOperationKHR m_deferredOperationKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" ); @@ -44204,10 +44194,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; public: - VULKAN_HPP_CONSTEXPR PipelineCache() VULKAN_HPP_NOEXCEPT : m_pipelineCache( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR PipelineCache() = default; + VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {} @@ -44222,7 +44210,7 @@ namespace VULKAN_HPP_NAMESPACE PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_pipelineCache = VK_NULL_HANDLE; + m_pipelineCache = {}; return *this; } @@ -44261,7 +44249,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPipelineCache m_pipelineCache; + VkPipelineCache m_pipelineCache = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); @@ -47860,12 +47848,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT() VULKAN_HPP_NOEXCEPT : m_privateDataSlotEXT( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_privateDataSlotEXT( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT() = default; + VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT : m_privateDataSlotEXT( privateDataSlotEXT ) {} @@ -47880,7 +47864,7 @@ namespace VULKAN_HPP_NAMESPACE PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_privateDataSlotEXT = VK_NULL_HANDLE; + m_privateDataSlotEXT = {}; return *this; } @@ -47919,7 +47903,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPrivateDataSlotEXT m_privateDataSlotEXT; + VkPrivateDataSlotEXT m_privateDataSlotEXT = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ), "handle and wrapper have different size!" ); @@ -50517,12 +50501,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion; public: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_samplerYcbcrConversion( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( samplerYcbcrConversion ) @@ -50538,7 +50518,7 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_samplerYcbcrConversion = VK_NULL_HANDLE; + m_samplerYcbcrConversion = {}; return *this; } @@ -50577,7 +50557,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkSamplerYcbcrConversion m_samplerYcbcrConversion; + VkSamplerYcbcrConversion m_samplerYcbcrConversion = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); @@ -50811,10 +50791,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; public: - VULKAN_HPP_CONSTEXPR SurfaceKHR() VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR SurfaceKHR() = default; + VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {} @@ -50828,7 +50806,7 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_surfaceKHR = VK_NULL_HANDLE; + m_surfaceKHR = {}; return *this; } @@ -50867,7 +50845,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkSurfaceKHR m_surfaceKHR; + VkSurfaceKHR m_surfaceKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); @@ -51303,12 +51281,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT; public: - VULKAN_HPP_CONSTEXPR ValidationCacheEXT() VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_validationCacheEXT( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default; + VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT ) {} @@ -51323,7 +51297,7 @@ namespace VULKAN_HPP_NAMESPACE ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_validationCacheEXT = VK_NULL_HANDLE; + m_validationCacheEXT = {}; return *this; } @@ -51362,7 +51336,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkValidationCacheEXT m_validationCacheEXT; + VkValidationCacheEXT m_validationCacheEXT = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); @@ -53013,10 +52987,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; public: - VULKAN_HPP_CONSTEXPR Queue() VULKAN_HPP_NOEXCEPT : m_queue( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_queue( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Queue() = default; + VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -53029,7 +53001,7 @@ namespace VULKAN_HPP_NAMESPACE Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_queue = VK_NULL_HANDLE; + m_queue = {}; return *this; } @@ -53203,7 +53175,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkQueue m_queue; + VkQueue m_queue = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); @@ -57573,10 +57545,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; public: - VULKAN_HPP_CONSTEXPR Device() VULKAN_HPP_NOEXCEPT : m_device( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_device( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Device() = default; + VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -57589,7 +57559,7 @@ namespace VULKAN_HPP_NAMESPACE Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_device = VK_NULL_HANDLE; + m_device = {}; return *this; } @@ -61711,7 +61681,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDevice m_device; + VkDevice m_device = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); @@ -61911,10 +61881,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; public: - VULKAN_HPP_CONSTEXPR DisplayModeKHR() VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default; + VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {} @@ -61929,7 +61897,7 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_displayModeKHR = VK_NULL_HANDLE; + m_displayModeKHR = {}; return *this; } @@ -61968,7 +61936,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDisplayModeKHR m_displayModeKHR; + VkDisplayModeKHR m_displayModeKHR = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); @@ -66421,10 +66389,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; public: - VULKAN_HPP_CONSTEXPR PhysicalDevice() VULKAN_HPP_NOEXCEPT : m_physicalDevice( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR PhysicalDevice() = default; + VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {} @@ -66439,7 +66405,7 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_physicalDevice = VK_NULL_HANDLE; + m_physicalDevice = {}; return *this; } @@ -67782,7 +67748,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkPhysicalDevice m_physicalDevice; + VkPhysicalDevice m_physicalDevice = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); @@ -77688,6 +77654,115 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExclusiveScissorFeaturesNV; }; + struct PhysicalDeviceExtendedDynamicState2FeaturesEXT + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT( + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2LogicOp_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2PatchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT + : extendedDynamicState2( extendedDynamicState2_ ) + , extendedDynamicState2LogicOp( extendedDynamicState2LogicOp_ ) + , extendedDynamicState2PatchControlPoints( extendedDynamicState2PatchControlPoints_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT( + PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicState2FeaturesEXT( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedDynamicState2FeaturesEXT( + *reinterpret_cast<PhysicalDeviceExtendedDynamicState2FeaturesEXT const *>( &rhs ) ) + {} +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & + operator=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & + operator=( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const *>( &rhs ); + return *this; + } + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & + setExtendedDynamicState2( VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2_ ) VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2 = extendedDynamicState2_; + return *this; + } + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & + setExtendedDynamicState2LogicOp( VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2LogicOp_ ) VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_; + return *this; + } + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2PatchControlPoints( + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2PatchControlPoints_ ) VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_; + return *this; + } + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && + ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && + ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); + } + + bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2 = {}; + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2LogicOp = {}; + VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2PatchControlPoints = {}; + }; + static_assert( sizeof( PhysicalDeviceExtendedDynamicState2FeaturesEXT ) == + sizeof( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT ), + "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout<PhysicalDeviceExtendedDynamicState2FeaturesEXT>::value, + "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT> + { + using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + }; + struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { static const bool allowDuplicate = false; @@ -99231,12 +99306,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT; public: - VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_debugReportCallbackEXT( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default; + VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( debugReportCallbackEXT ) @@ -99252,7 +99323,7 @@ namespace VULKAN_HPP_NAMESPACE DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_debugReportCallbackEXT = VK_NULL_HANDLE; + m_debugReportCallbackEXT = {}; return *this; } @@ -99291,7 +99362,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDebugReportCallbackEXT m_debugReportCallbackEXT; + VkDebugReportCallbackEXT m_debugReportCallbackEXT = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); @@ -99333,12 +99404,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_debugUtilsMessengerEXT( VK_NULL_HANDLE ) - {} - + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default; + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) @@ -99354,7 +99421,7 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_debugUtilsMessengerEXT = VK_NULL_HANDLE; + m_debugUtilsMessengerEXT = {}; return *this; } @@ -99393,7 +99460,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT; + VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); @@ -99453,10 +99520,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; public: - VULKAN_HPP_CONSTEXPR Instance() VULKAN_HPP_NOEXCEPT : m_instance( VK_NULL_HANDLE ) {} - - VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_instance( VK_NULL_HANDLE ) {} - + VULKAN_HPP_CONSTEXPR Instance() = default; + VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {} #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) @@ -99469,7 +99534,7 @@ namespace VULKAN_HPP_NAMESPACE Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT { - m_instance = VK_NULL_HANDLE; + m_instance = {}; return *this; } @@ -100127,7 +100192,7 @@ namespace VULKAN_HPP_NAMESPACE } private: - VkInstance m_instance; + VkInstance m_instance = {}; }; static_assert( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); @@ -102423,6 +102488,13 @@ namespace VULKAN_HPP_NAMESPACE } template <typename Dispatch> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) ); + } + + template <typename Dispatch> VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT @@ -102611,6 +102683,20 @@ namespace VULKAN_HPP_NAMESPACE } template <typename Dispatch> + VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) ); + } + + template <typename Dispatch> + VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints ); + } + + template <typename Dispatch> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { @@ -102673,6 +102759,14 @@ namespace VULKAN_HPP_NAMESPACE template <typename Dispatch> VULKAN_HPP_INLINE void + CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) ); + } + + template <typename Dispatch> + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { @@ -102681,6 +102775,14 @@ namespace VULKAN_HPP_NAMESPACE template <typename Dispatch> VULKAN_HPP_INLINE void + CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) ); + } + + template <typename Dispatch> + VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { @@ -119011,6 +119113,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2> + { + enum + { + value = true + }; + }; + template <> + struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo> + { + enum + { + value = true + }; + }; + template <> struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2> { enum @@ -121515,6 +121633,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; + PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; @@ -121531,10 +121650,14 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; + PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; + PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; + PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; + PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; PFN_vkCmdSetScissor vkCmdSetScissor = 0; @@ -122119,7 +122242,7 @@ namespace VULKAN_HPP_NAMESPACE // This interface does not require a linked vulkan library. DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, - VkDevice device = VK_NULL_HANDLE, + VkDevice device = {}, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT { init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); @@ -122128,7 +122251,7 @@ namespace VULKAN_HPP_NAMESPACE // This interface does not require a linked vulkan library. void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, - VkDevice device = VK_NULL_HANDLE, + VkDevice device = {}, PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( instance && getInstanceProcAddr ); @@ -122618,6 +122741,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) ); vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) ); vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) ); + vkCmdSetDepthBiasEnableEXT = + PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) ); vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) ); vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) ); @@ -122644,15 +122769,22 @@ namespace VULKAN_HPP_NAMESPACE vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) ); vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) ); - vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); + vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) ); + vkCmdSetPatchControlPointsEXT = + PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) ); vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); + vkCmdSetPrimitiveRestartEnableEXT = + PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) ); vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) ); + vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( + vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) ); vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); vkCmdSetSampleLocationsEXT = @@ -123338,6 +123470,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); + vkCmdSetDepthBiasEnableEXT = + PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); @@ -123364,14 +123498,21 @@ namespace VULKAN_HPP_NAMESPACE vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); + vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); + vkCmdSetPatchControlPointsEXT = + PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); + vkCmdSetPrimitiveRestartEnableEXT = + PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); + vkCmdSetRasterizerDiscardEnableEXT = + PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); vkCmdSetSampleLocationsEXT = |