diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index e1c079d..9d45277 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ # define VULKAN_HPP_ASSERT assert #endif -static_assert( VK_HEADER_VERSION == 114 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 115 , "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 @@ -123,8 +123,10 @@ static_assert( VK_HEADER_VERSION == 114 , "Wrong VK_HEADER_VERSION!" ); #if defined(_MSC_VER) && (_MSC_VER <= 1800) # define VULKAN_HPP_CONSTEXPR +# define VULKAN_HPP_CONST_OR_CONSTEXPR const #else # define VULKAN_HPP_CONSTEXPR constexpr +# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr #endif #if !defined(VULKAN_HPP_NAMESPACE) @@ -5123,7 +5125,7 @@ namespace VULKAN_HPP_NAMESPACE eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, - ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, + ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, @@ -5263,7 +5265,7 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, - ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL, + ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, @@ -5342,6 +5344,7 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, + ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, @@ -5549,7 +5552,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT"; case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT"; case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT"; - case StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR : return "PhysicalDeviceFloat16Int8FeaturesKHR"; + case StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR : return "PhysicalDeviceShaderFloat16Int8FeaturesKHR"; case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR"; case StructureType::eObjectTableCreateInfoNVX : return "ObjectTableCreateInfoNVX"; case StructureType::eIndirectCommandsLayoutCreateInfoNVX : return "IndirectCommandsLayoutCreateInfoNVX"; @@ -5947,6 +5950,11 @@ namespace VULKAN_HPP_NAMESPACE } } + template + struct cpp_type + { + }; + enum class AccessFlagBits { eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, @@ -11312,7 +11320,6 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceFeatures; struct PhysicalDeviceFeatures2; using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; - struct PhysicalDeviceFloat16Int8FeaturesKHR; struct PhysicalDeviceFloatControlsPropertiesKHR; struct PhysicalDeviceFragmentDensityMapFeaturesEXT; struct PhysicalDeviceFragmentDensityMapPropertiesEXT; @@ -11366,8 +11373,10 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; struct PhysicalDeviceShaderDrawParametersFeatures; using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; + struct PhysicalDeviceShaderFloat16Int8FeaturesKHR; + using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8FeaturesKHR; struct PhysicalDeviceShaderImageFootprintFeaturesNV; - struct PhysicalDeviceShaderIntegerFunctions2INTEL; + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; struct PhysicalDeviceShaderSMBuiltinsFeaturesNV; struct PhysicalDeviceShaderSMBuiltinsPropertiesNV; struct PhysicalDeviceShadingRateImageFeaturesNV; @@ -11562,6 +11571,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; + public: VULKAN_HPP_CONSTEXPR SurfaceKHR() : m_surfaceKHR(VK_NULL_HANDLE) @@ -11624,11 +11635,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = SurfaceKHR; + }; + class DebugReportCallbackEXT { public: using CType = VkDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; + public: VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() : m_debugReportCallbackEXT(VK_NULL_HANDLE) @@ -11691,11 +11710,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DebugReportCallbackEXT; + }; + class DebugUtilsMessengerEXT { public: using CType = VkDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; + public: VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() : m_debugUtilsMessengerEXT(VK_NULL_HANDLE) @@ -11758,11 +11785,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DebugUtilsMessengerEXT; + }; + class DisplayKHR { public: using CType = VkDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; + public: VULKAN_HPP_CONSTEXPR DisplayKHR() : m_displayKHR(VK_NULL_HANDLE) @@ -11825,11 +11860,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DisplayKHR; + }; + class SwapchainKHR { public: using CType = VkSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; + public: VULKAN_HPP_CONSTEXPR SwapchainKHR() : m_swapchainKHR(VK_NULL_HANDLE) @@ -11892,11 +11935,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = SwapchainKHR; + }; + class Semaphore { public: using CType = VkSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; + public: VULKAN_HPP_CONSTEXPR Semaphore() : m_semaphore(VK_NULL_HANDLE) @@ -11959,11 +12010,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Semaphore; + }; + class Fence { public: using CType = VkFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; + public: VULKAN_HPP_CONSTEXPR Fence() : m_fence(VK_NULL_HANDLE) @@ -12026,11 +12085,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Fence; + }; + class PerformanceConfigurationINTEL { public: using CType = VkPerformanceConfigurationINTEL; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; + public: VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() : m_performanceConfigurationINTEL(VK_NULL_HANDLE) @@ -12093,11 +12160,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = PerformanceConfigurationINTEL; + }; + class QueryPool { public: using CType = VkQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; + public: VULKAN_HPP_CONSTEXPR QueryPool() : m_queryPool(VK_NULL_HANDLE) @@ -12160,11 +12235,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = QueryPool; + }; + class Buffer { public: using CType = VkBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; + public: VULKAN_HPP_CONSTEXPR Buffer() : m_buffer(VK_NULL_HANDLE) @@ -12227,11 +12310,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Buffer; + }; + class PipelineLayout { public: using CType = VkPipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; + public: VULKAN_HPP_CONSTEXPR PipelineLayout() : m_pipelineLayout(VK_NULL_HANDLE) @@ -12294,11 +12385,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = PipelineLayout; + }; + class DescriptorSet { public: using CType = VkDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; + public: VULKAN_HPP_CONSTEXPR DescriptorSet() : m_descriptorSet(VK_NULL_HANDLE) @@ -12361,11 +12460,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DescriptorSet; + }; + class Pipeline { public: using CType = VkPipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; + public: VULKAN_HPP_CONSTEXPR Pipeline() : m_pipeline(VK_NULL_HANDLE) @@ -12428,11 +12535,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Pipeline; + }; + class ImageView { public: using CType = VkImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; + public: VULKAN_HPP_CONSTEXPR ImageView() : m_imageView(VK_NULL_HANDLE) @@ -12495,11 +12610,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = ImageView; + }; + class Image { public: using CType = VkImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; + public: VULKAN_HPP_CONSTEXPR Image() : m_image(VK_NULL_HANDLE) @@ -12562,11 +12685,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Image; + }; + class AccelerationStructureNV { public: using CType = VkAccelerationStructureNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; + public: VULKAN_HPP_CONSTEXPR AccelerationStructureNV() : m_accelerationStructureNV(VK_NULL_HANDLE) @@ -12629,11 +12760,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = AccelerationStructureNV; + }; + class DescriptorUpdateTemplate { public: using CType = VkDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; + public: VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() : m_descriptorUpdateTemplate(VK_NULL_HANDLE) @@ -12695,6 +12834,12 @@ namespace VULKAN_HPP_NAMESPACE VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; }; static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); + + template <> + struct cpp_type + { + using type = DescriptorUpdateTemplate; + }; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; class Event @@ -12702,6 +12847,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; + public: VULKAN_HPP_CONSTEXPR Event() : m_event(VK_NULL_HANDLE) @@ -12764,11 +12911,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Event; + }; + class CommandBuffer { public: using CType = VkCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; + public: VULKAN_HPP_CONSTEXPR CommandBuffer() : m_commandBuffer(VK_NULL_HANDLE) @@ -13306,11 +13461,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = CommandBuffer; + }; + class DeviceMemory { public: using CType = VkDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; + public: VULKAN_HPP_CONSTEXPR DeviceMemory() : m_deviceMemory(VK_NULL_HANDLE) @@ -13373,11 +13536,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DeviceMemory; + }; + class BufferView { public: using CType = VkBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; + public: VULKAN_HPP_CONSTEXPR BufferView() : m_bufferView(VK_NULL_HANDLE) @@ -13440,11 +13611,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = BufferView; + }; + class CommandPool { public: using CType = VkCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; + public: VULKAN_HPP_CONSTEXPR CommandPool() : m_commandPool(VK_NULL_HANDLE) @@ -13507,11 +13686,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = CommandPool; + }; + class PipelineCache { public: using CType = VkPipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; + public: VULKAN_HPP_CONSTEXPR PipelineCache() : m_pipelineCache(VK_NULL_HANDLE) @@ -13574,11 +13761,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = PipelineCache; + }; + class DescriptorPool { public: using CType = VkDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; + public: VULKAN_HPP_CONSTEXPR DescriptorPool() : m_descriptorPool(VK_NULL_HANDLE) @@ -13641,11 +13836,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DescriptorPool; + }; + class DescriptorSetLayout { public: using CType = VkDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; + public: VULKAN_HPP_CONSTEXPR DescriptorSetLayout() : m_descriptorSetLayout(VK_NULL_HANDLE) @@ -13708,11 +13911,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DescriptorSetLayout; + }; + class Framebuffer { public: using CType = VkFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; + public: VULKAN_HPP_CONSTEXPR Framebuffer() : m_framebuffer(VK_NULL_HANDLE) @@ -13775,11 +13986,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Framebuffer; + }; + class IndirectCommandsLayoutNVX { public: using CType = VkIndirectCommandsLayoutNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX; + public: VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX() : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) @@ -13842,11 +14061,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = IndirectCommandsLayoutNVX; + }; + class ObjectTableNVX { public: using CType = VkObjectTableNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX; + public: VULKAN_HPP_CONSTEXPR ObjectTableNVX() : m_objectTableNVX(VK_NULL_HANDLE) @@ -13909,11 +14136,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = ObjectTableNVX; + }; + class RenderPass { public: using CType = VkRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; + public: VULKAN_HPP_CONSTEXPR RenderPass() : m_renderPass(VK_NULL_HANDLE) @@ -13976,11 +14211,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = RenderPass; + }; + class Sampler { public: using CType = VkSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; + public: VULKAN_HPP_CONSTEXPR Sampler() : m_sampler(VK_NULL_HANDLE) @@ -14043,11 +14286,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Sampler; + }; + class SamplerYcbcrConversion { public: using CType = VkSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; + public: VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() : m_samplerYcbcrConversion(VK_NULL_HANDLE) @@ -14109,6 +14360,12 @@ namespace VULKAN_HPP_NAMESPACE VkSamplerYcbcrConversion m_samplerYcbcrConversion; }; static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); + + template <> + struct cpp_type + { + using type = SamplerYcbcrConversion; + }; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; class ShaderModule @@ -14116,6 +14373,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; + public: VULKAN_HPP_CONSTEXPR ShaderModule() : m_shaderModule(VK_NULL_HANDLE) @@ -14178,11 +14437,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = ShaderModule; + }; + class ValidationCacheEXT { public: using CType = VkValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; + public: VULKAN_HPP_CONSTEXPR ValidationCacheEXT() : m_validationCacheEXT(VK_NULL_HANDLE) @@ -14245,11 +14512,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = ValidationCacheEXT; + }; + class Queue { public: using CType = VkQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; + public: VULKAN_HPP_CONSTEXPR Queue() : m_queue(VK_NULL_HANDLE) @@ -14375,6 +14650,12 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Queue; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; @@ -14440,6 +14721,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; + public: VULKAN_HPP_CONSTEXPR Device() : m_device(VK_NULL_HANDLE) @@ -16073,11 +16356,19 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Device; + }; + class DisplayModeKHR { public: using CType = VkDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; + public: VULKAN_HPP_CONSTEXPR DisplayModeKHR() : m_displayModeKHR(VK_NULL_HANDLE) @@ -16140,6 +16431,12 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = DisplayModeKHR; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDevice = UniqueHandle; @@ -16150,6 +16447,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; + public: VULKAN_HPP_CONSTEXPR PhysicalDevice() : m_physicalDevice(VK_NULL_HANDLE) @@ -16737,6 +17036,12 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = PhysicalDevice; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Instance; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; @@ -16752,6 +17057,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; + public: VULKAN_HPP_CONSTEXPR Instance() : m_instance(VK_NULL_HANDLE) @@ -17098,6 +17405,12 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); + template <> + struct cpp_type + { + using type = Instance; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueInstance = UniqueHandle; @@ -38763,76 +39076,6 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); - struct PhysicalDeviceFloat16Int8FeaturesKHR - { - PhysicalDeviceFloat16Int8FeaturesKHR( Bool32 shaderFloat16_ = 0, - Bool32 shaderInt8_ = 0 ) - : shaderFloat16( shaderFloat16_ ) - , shaderInt8( shaderInt8_ ) - {} - - PhysicalDeviceFloat16Int8FeaturesKHR( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs ) - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs ) - { - *reinterpret_cast(this) = rhs; - return *this; - } - - PhysicalDeviceFloat16Int8FeaturesKHR & setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceFloat16Int8FeaturesKHR & setShaderFloat16( Bool32 shaderFloat16_ ) - { - shaderFloat16 = shaderFloat16_; - return *this; - } - - PhysicalDeviceFloat16Int8FeaturesKHR & setShaderInt8( Bool32 shaderInt8_ ) - { - shaderInt8 = shaderInt8_; - return *this; - } - - operator VkPhysicalDeviceFloat16Int8FeaturesKHR const&() const - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFloat16Int8FeaturesKHR &() - { - return *reinterpret_cast( this ); - } - - bool operator==( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( shaderFloat16 == rhs.shaderFloat16 ) - && ( shaderInt8 == rhs.shaderInt8 ); - } - - bool operator!=( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR; - - public: - void* pNext = nullptr; - Bool32 shaderFloat16; - Bool32 shaderInt8; - }; - static_assert( sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceFloatControlsPropertiesKHR { operator VkPhysicalDeviceFloatControlsPropertiesKHR const&() const @@ -41236,6 +41479,76 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" ); + struct PhysicalDeviceShaderFloat16Int8FeaturesKHR + { + PhysicalDeviceShaderFloat16Int8FeaturesKHR( Bool32 shaderFloat16_ = 0, + Bool32 shaderInt8_ = 0 ) + : shaderFloat16( shaderFloat16_ ) + , shaderInt8( shaderInt8_ ) + {} + + PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDeviceShaderFloat16Int8FeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderFloat16( Bool32 shaderFloat16_ ) + { + shaderFloat16 = shaderFloat16_; + return *this; + } + + PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderInt8( Bool32 shaderInt8_ ) + { + shaderInt8 = shaderInt8_; + return *this; + } + + operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderFloat16 == rhs.shaderFloat16 ) + && ( shaderInt8 == rhs.shaderInt8 ); + } + + bool operator!=( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 shaderFloat16; + Bool32 shaderInt8; + }; + static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" ); + struct PhysicalDeviceShaderImageFootprintFeaturesNV { PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 ) @@ -41296,53 +41609,53 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); - struct PhysicalDeviceShaderIntegerFunctions2INTEL + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - PhysicalDeviceShaderIntegerFunctions2INTEL( Bool32 shaderIntegerFunctions2_ = 0 ) + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( Bool32 shaderIntegerFunctions2_ = 0 ) : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) {} - PhysicalDeviceShaderIntegerFunctions2INTEL( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs ) + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) { - *reinterpret_cast(this) = rhs; + *reinterpret_cast(this) = rhs; } - PhysicalDeviceShaderIntegerFunctions2INTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs ) + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) { - *reinterpret_cast(this) = rhs; + *reinterpret_cast(this) = rhs; return *this; } - PhysicalDeviceShaderIntegerFunctions2INTEL & setPNext( void* pNext_ ) + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceShaderIntegerFunctions2INTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) { shaderIntegerFunctions2 = shaderIntegerFunctions2_; return *this; } - operator VkPhysicalDeviceShaderIntegerFunctions2INTEL const&() const + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const&() const { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderIntegerFunctions2INTEL &() + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - bool operator==( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const + bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); } - bool operator!=( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const + bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const { return !operator==( rhs ); } @@ -41354,7 +41667,7 @@ namespace VULKAN_HPP_NAMESPACE void* pNext = nullptr; Bool32 shaderIntegerFunctions2; }; - static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2INTEL ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" ); struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { @@ -58152,8 +58465,6 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -58205,10 +58516,12 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -58218,7 +58531,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 544f24f..623b031 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -43,7 +43,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 114 +#define VK_HEADER_VERSION 115 #define VK_NULL_HANDLE 0 @@ -327,7 +327,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, @@ -467,7 +467,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL = 1000209000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000, VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, @@ -546,6 +546,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, @@ -5535,12 +5536,14 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( #define VK_KHR_shader_float16_int8 1 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" -typedef struct VkPhysicalDeviceFloat16Int8FeaturesKHR { +typedef struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR { VkStructureType sType; void* pNext; VkBool32 shaderFloat16; VkBool32 shaderInt8; -} VkPhysicalDeviceFloat16Int8FeaturesKHR; +} VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; + +typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR; @@ -8977,13 +8980,13 @@ VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( #define VK_INTEL_shader_integer_functions2 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" -typedef struct VkPhysicalDeviceShaderIntegerFunctions2INTEL { +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" +typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { VkStructureType sType; void* pNext; VkBool32 shaderIntegerFunctions2; -} VkPhysicalDeviceShaderIntegerFunctions2INTEL; +} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; diff --git a/registry/validusage.json b/registry/validusage.json index 18d13e7..4f2e650 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.1.114", - "comment": "from git branch: github-master commit: 7eb07044df67e19e768080c7f378fc0938ead346", - "date": "2019-07-08 03:11:46Z" + "api version": "1.1.115", + "comment": "from git branch: github-master commit: 57b7cd572d2d9dafdcc18218175d984019c2c092", + "date": "2019-07-14 13:04:33Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -214,7 +214,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -362,7 +362,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFloat16Int8FeaturesKHR, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2INTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8FeaturesKHR, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -3046,7 +3046,7 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00838", - "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass" + "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass" }, { "vuid": "VUID-VkRenderPassCreateInfo-srcSubpass-02517", @@ -3560,11 +3560,11 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054", - "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass." + "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass" }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055", - "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass." + "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass" }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-03056", @@ -6402,11 +6402,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT or VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT" - }, - { - "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-unique", - "text": " Each sType member in the pNext chain must be unique" + "text": " pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT" } ] }, @@ -6994,7 +6990,7 @@ "(VK_EXT_external_memory_host)": [ { "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", - "text": " If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR" + "text": " If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryProperties" }, { "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", @@ -7106,7 +7102,7 @@ "(VK_ANDROID_external_memory_android_hardware_buffer)": [ { "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", - "text": " VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created." + "text": " VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created." }, { "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", @@ -8412,7 +8408,7 @@ "(VK_EXT_image_drm_format_modifier)": [ { "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264", - "text": " drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2KHR extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT." + "text": " drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT." }, { "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265", @@ -9702,7 +9698,7 @@ "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ { "vuid": "VUID-VkBindImageMemoryInfo-image-01630", - "text": " If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR" + "text": " If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR containing the same swapchain handle." }, { "vuid": "VUID-VkBindImageMemoryInfo-pNext-01631", @@ -11558,6 +11554,10 @@ "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00339", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set" }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02752", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding" + }, { "vuid": "VUID-VkWriteDescriptorSet-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET" @@ -11724,6 +11724,10 @@ "vuid": "VUID-VkCopyDescriptorSet-srcSet-00349", "text": " If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by consecutive binding updates" }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-02753", + "text": " If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding" + }, { "vuid": "VUID-VkCopyDescriptorSet-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET" @@ -23072,11 +23076,11 @@ } ] }, - "VkPhysicalDeviceFloat16Int8FeaturesKHR": { + "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR": { "(VK_KHR_shader_float16_int8)": [ { - "vuid": "VUID-VkPhysicalDeviceFloat16Int8FeaturesKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR" + "vuid": "VUID-VkPhysicalDeviceShaderFloat16Int8FeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR" } ] }, @@ -23328,11 +23332,11 @@ } ] }, - "VkPhysicalDeviceShaderIntegerFunctions2INTEL": { + "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL": { "(VK_INTEL_shader_integer_functions2)": [ { - "vuid": "VUID-VkPhysicalDeviceShaderIntegerFunctions2INTEL-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL" + "vuid": "VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL" } ] }, diff --git a/registry/vk.xml b/registry/vk.xml index e3d040a..d97223a 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -154,7 +154,7 @@ server. // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 114 +#define VK_HEADER_VERSION 115 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -2989,12 +2989,13 @@ typedef void CAMetalLayer; VkBool32 shaderDrawParameters - - VkStructureType sType + + VkStructureType sType void* pNext VkBool32 shaderFloat16 VkBool32 shaderInt8 + VkStructureType sType void* pNext @@ -3926,8 +3927,8 @@ typedef void CAMetalLayer; VkSampleCountFlags depthStencilSamples VkSampleCountFlags colorSamples - - VkStructureType sType + + VkStructureType sType void* pNext VkBool32 shaderIntegerFunctions2 @@ -4002,7 +4003,7 @@ typedef void CAMetalLayer; void* pNext VkBool32 texelBufferAlignment - + VkStructureType sType void* pNext VkDeviceSize storageTexelBufferOffsetAlignmentBytes @@ -9079,7 +9080,9 @@ typedef void CAMetalLayer; - + + + @@ -10587,10 +10590,10 @@ typedef void CAMetalLayer; - - - - + + + +