diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index b187249..4bb89e5 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -70,7 +70,7 @@ #undef MemoryBarrier #endif -static_assert( VK_HEADER_VERSION == 92 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 94 , "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 @@ -1037,7 +1037,7 @@ namespace VULKAN_HPP_NAMESPACE { #ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( result == Result::eSuccess ); - return ResultValue( result, data ); + return ResultValue( result, std::move(data) ); #else if ( result != Result::eSuccess ) { @@ -1080,7 +1080,7 @@ namespace VULKAN_HPP_NAMESPACE { #ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( result == Result::eSuccess ); - return ResultValue>( result, UniqueHandle(data, deleter) ); + return ResultValue>( result, UniqueHandle(std::move(data), deleter) ); #else if ( result != Result::eSuccess ) { @@ -2637,12 +2637,6 @@ public: using RenderPassCreateFlags = Flags; - enum class SamplerCreateFlagBits - { - }; - - using SamplerCreateFlags = Flags; - enum class PipelineLayoutCreateFlagBits { }; @@ -2733,12 +2727,6 @@ public: using DeviceCreateFlags = Flags; - enum class ImageViewCreateFlagBits - { - }; - - using ImageViewCreateFlags = Flags; - enum class SemaphoreCreateFlagBits { }; @@ -7914,7 +7902,8 @@ public: eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, - eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV + eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, + eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT }; struct DescriptorImageInfo @@ -9494,7 +9483,12 @@ public: eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, - eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA + eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, + ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, + eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, + ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT }; struct ApplicationInfo @@ -11107,216 +11101,6 @@ public: }; static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); - struct SamplerCreateInfo - { - SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), - Filter magFilter_ = Filter::eNearest, - Filter minFilter_ = Filter::eNearest, - SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, - SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, - float mipLodBias_ = 0, - Bool32 anisotropyEnable_ = 0, - float maxAnisotropy_ = 0, - Bool32 compareEnable_ = 0, - CompareOp compareOp_ = CompareOp::eNever, - float minLod_ = 0, - float maxLod_ = 0, - BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, - Bool32 unnormalizedCoordinates_ = 0 ) - : flags( flags_ ) - , magFilter( magFilter_ ) - , minFilter( minFilter_ ) - , mipmapMode( mipmapMode_ ) - , addressModeU( addressModeU_ ) - , addressModeV( addressModeV_ ) - , addressModeW( addressModeW_ ) - , mipLodBias( mipLodBias_ ) - , anisotropyEnable( anisotropyEnable_ ) - , maxAnisotropy( maxAnisotropy_ ) - , compareEnable( compareEnable_ ) - , compareOp( compareOp_ ) - , minLod( minLod_ ) - , maxLod( maxLod_ ) - , borderColor( borderColor_ ) - , unnormalizedCoordinates( unnormalizedCoordinates_ ) - { - } - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - } - - SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - return *this; - } - SamplerCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - SamplerCreateInfo& setMagFilter( Filter magFilter_ ) - { - magFilter = magFilter_; - return *this; - } - - SamplerCreateInfo& setMinFilter( Filter minFilter_ ) - { - minFilter = minFilter_; - return *this; - } - - SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ ) - { - mipmapMode = mipmapMode_; - return *this; - } - - SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ ) - { - addressModeU = addressModeU_; - return *this; - } - - SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ ) - { - addressModeV = addressModeV_; - return *this; - } - - SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ ) - { - addressModeW = addressModeW_; - return *this; - } - - SamplerCreateInfo& setMipLodBias( float mipLodBias_ ) - { - mipLodBias = mipLodBias_; - return *this; - } - - SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ ) - { - anisotropyEnable = anisotropyEnable_; - return *this; - } - - SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ ) - { - maxAnisotropy = maxAnisotropy_; - return *this; - } - - SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ ) - { - compareEnable = compareEnable_; - return *this; - } - - SamplerCreateInfo& setCompareOp( CompareOp compareOp_ ) - { - compareOp = compareOp_; - return *this; - } - - SamplerCreateInfo& setMinLod( float minLod_ ) - { - minLod = minLod_; - return *this; - } - - SamplerCreateInfo& setMaxLod( float maxLod_ ) - { - maxLod = maxLod_; - return *this; - } - - SamplerCreateInfo& setBorderColor( BorderColor borderColor_ ) - { - borderColor = borderColor_; - return *this; - } - - SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) - { - unnormalizedCoordinates = unnormalizedCoordinates_; - return *this; - } - - operator VkSamplerCreateInfo const&() const - { - return *reinterpret_cast(this); - } - - operator VkSamplerCreateInfo &() - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( magFilter == rhs.magFilter ) - && ( minFilter == rhs.minFilter ) - && ( mipmapMode == rhs.mipmapMode ) - && ( addressModeU == rhs.addressModeU ) - && ( addressModeV == rhs.addressModeV ) - && ( addressModeW == rhs.addressModeW ) - && ( mipLodBias == rhs.mipLodBias ) - && ( anisotropyEnable == rhs.anisotropyEnable ) - && ( maxAnisotropy == rhs.maxAnisotropy ) - && ( compareEnable == rhs.compareEnable ) - && ( compareOp == rhs.compareOp ) - && ( minLod == rhs.minLod ) - && ( maxLod == rhs.maxLod ) - && ( borderColor == rhs.borderColor ) - && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); - } - - bool operator!=( SamplerCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerCreateInfo; - - public: - const void* pNext = nullptr; - SamplerCreateFlags flags; - Filter magFilter; - Filter minFilter; - SamplerMipmapMode mipmapMode; - SamplerAddressMode addressModeU; - SamplerAddressMode addressModeV; - SamplerAddressMode addressModeW; - float mipLodBias; - Bool32 anisotropyEnable; - float maxAnisotropy; - Bool32 compareEnable; - CompareOp compareOp; - float minLod; - float maxLod; - BorderColor borderColor; - Bool32 unnormalizedCoordinates; - }; - static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); - struct CommandBufferAllocateInfo { CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), @@ -21113,6 +20897,200 @@ public: }; static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); + struct PhysicalDeviceFragmentDensityMapFeaturesEXT + { + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const + { + return *reinterpret_cast(this); + } + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fragmentDensityMap == rhs.fragmentDensityMap ) + && ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) + && ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 fragmentDensityMap; + Bool32 fragmentDensityMapDynamic; + Bool32 fragmentDensityMapNonSubsampledImages; + }; + static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFragmentDensityMapPropertiesEXT + { + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const + { + return *reinterpret_cast(this); + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) + && ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) + && ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + + public: + void* pNext = nullptr; + Extent2D minFragmentDensityTexelSize; + Extent2D maxFragmentDensityTexelSize; + Bool32 fragmentDensityInvocations; + }; + static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" ); + + struct RenderPassFragmentDensityMapCreateInfoEXT + { + RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() ) + : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) + { + } + + RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) ); + } + + RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) ); + return *this; + } + RenderPassFragmentDensityMapCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassFragmentDensityMapCreateInfoEXT& setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ ) + { + fragmentDensityMapAttachment = fragmentDensityMapAttachment_; + return *this; + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const + { + return *reinterpret_cast(this); + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT &() + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); + } + + bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + + public: + const void* pNext = nullptr; + AttachmentReference fragmentDensityMapAttachment; + }; + static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceScalarBlockLayoutFeaturesEXT + { + PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 ) + : scalarBlockLayout( scalarBlockLayout_ ) + { + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) ); + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) ); + return *this; + } + PhysicalDeviceScalarBlockLayoutFeaturesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT& setScalarBlockLayout( Bool32 scalarBlockLayout_ ) + { + scalarBlockLayout = scalarBlockLayout_; + return *this; + } + + operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const&() const + { + return *reinterpret_cast(this); + } + + operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT &() + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( scalarBlockLayout == rhs.scalarBlockLayout ); + } + + bool operator!=( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 scalarBlockLayout; + }; + static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" ); + enum class SubpassContents { eInline = VK_SUBPASS_CONTENTS_INLINE, @@ -21426,7 +21404,7 @@ public: memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) ); return *this; } - DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ ) + DescriptorUpdateTemplateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; @@ -21513,7 +21491,7 @@ public: StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; public: - void* pNext = nullptr; + const void* pNext = nullptr; DescriptorUpdateTemplateCreateFlags flags; uint32_t descriptorUpdateEntryCount; const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; @@ -22530,7 +22508,8 @@ public: eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, - eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV + eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV, + eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT }; using AccessFlags = Flags; @@ -22549,7 +22528,7 @@ public: { enum { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) + allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) | VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT) }; }; @@ -23360,7 +23339,8 @@ public: eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, - eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV + eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, + eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT }; using ImageUsageFlags = Flags; @@ -23379,7 +23359,7 @@ public: { enum { - allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV) + allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV) | VkFlags(ImageUsageFlagBits::eFragmentDensityMapEXT) }; }; @@ -23478,6 +23458,66 @@ public: using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; + struct ImageStencilUsageCreateInfoEXT + { + ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() ) + : stencilUsage( stencilUsage_ ) + { + } + + ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) ); + } + + ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) ); + return *this; + } + ImageStencilUsageCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageStencilUsageCreateInfoEXT& setStencilUsage( ImageUsageFlags stencilUsage_ ) + { + stencilUsage = stencilUsage_; + return *this; + } + + operator VkImageStencilUsageCreateInfoEXT const&() const + { + return *reinterpret_cast(this); + } + + operator VkImageStencilUsageCreateInfoEXT &() + { + return *reinterpret_cast(this); + } + + bool operator==( ImageStencilUsageCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( stencilUsage == rhs.stencilUsage ); + } + + bool operator!=( ImageStencilUsageCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; + + public: + const void* pNext = nullptr; + ImageUsageFlags stencilUsage; + }; + static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" ); + enum class ImageCreateFlagBits { eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, @@ -23499,7 +23539,8 @@ public: eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT, eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, - eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT + eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, + eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT }; using ImageCreateFlags = Flags; @@ -23518,7 +23559,7 @@ public: { enum { - allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) + allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eSubsampledEXT) }; }; @@ -23624,6 +23665,267 @@ public: using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + enum class ImageViewCreateFlagBits + { + eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT + }; + + using ImageViewCreateFlags = Flags; + + VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 ) + { + return ImageViewCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits ) + { + return ~( ImageViewCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) + }; + }; + + enum class SamplerCreateFlagBits + { + eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, + eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT + }; + + using SamplerCreateFlags = Flags; + + VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 ) + { + return SamplerCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SamplerCreateFlags operator~( SamplerCreateFlagBits bits ) + { + return ~( SamplerCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SamplerCreateFlagBits::eSubsampledEXT) | VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT) + }; + }; + + struct SamplerCreateInfo + { + SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), + Filter magFilter_ = Filter::eNearest, + Filter minFilter_ = Filter::eNearest, + SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, + SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, + float mipLodBias_ = 0, + Bool32 anisotropyEnable_ = 0, + float maxAnisotropy_ = 0, + Bool32 compareEnable_ = 0, + CompareOp compareOp_ = CompareOp::eNever, + float minLod_ = 0, + float maxLod_ = 0, + BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, + Bool32 unnormalizedCoordinates_ = 0 ) + : flags( flags_ ) + , magFilter( magFilter_ ) + , minFilter( minFilter_ ) + , mipmapMode( mipmapMode_ ) + , addressModeU( addressModeU_ ) + , addressModeV( addressModeV_ ) + , addressModeW( addressModeW_ ) + , mipLodBias( mipLodBias_ ) + , anisotropyEnable( anisotropyEnable_ ) + , maxAnisotropy( maxAnisotropy_ ) + , compareEnable( compareEnable_ ) + , compareOp( compareOp_ ) + , minLod( minLod_ ) + , maxLod( maxLod_ ) + , borderColor( borderColor_ ) + , unnormalizedCoordinates( unnormalizedCoordinates_ ) + { + } + + SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); + } + + SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); + return *this; + } + SamplerCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + SamplerCreateInfo& setMagFilter( Filter magFilter_ ) + { + magFilter = magFilter_; + return *this; + } + + SamplerCreateInfo& setMinFilter( Filter minFilter_ ) + { + minFilter = minFilter_; + return *this; + } + + SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ ) + { + mipmapMode = mipmapMode_; + return *this; + } + + SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ ) + { + addressModeU = addressModeU_; + return *this; + } + + SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ ) + { + addressModeV = addressModeV_; + return *this; + } + + SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ ) + { + addressModeW = addressModeW_; + return *this; + } + + SamplerCreateInfo& setMipLodBias( float mipLodBias_ ) + { + mipLodBias = mipLodBias_; + return *this; + } + + SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ ) + { + anisotropyEnable = anisotropyEnable_; + return *this; + } + + SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ ) + { + maxAnisotropy = maxAnisotropy_; + return *this; + } + + SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ ) + { + compareEnable = compareEnable_; + return *this; + } + + SamplerCreateInfo& setCompareOp( CompareOp compareOp_ ) + { + compareOp = compareOp_; + return *this; + } + + SamplerCreateInfo& setMinLod( float minLod_ ) + { + minLod = minLod_; + return *this; + } + + SamplerCreateInfo& setMaxLod( float maxLod_ ) + { + maxLod = maxLod_; + return *this; + } + + SamplerCreateInfo& setBorderColor( BorderColor borderColor_ ) + { + borderColor = borderColor_; + return *this; + } + + SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) + { + unnormalizedCoordinates = unnormalizedCoordinates_; + return *this; + } + + operator VkSamplerCreateInfo const&() const + { + return *reinterpret_cast(this); + } + + operator VkSamplerCreateInfo &() + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( magFilter == rhs.magFilter ) + && ( minFilter == rhs.minFilter ) + && ( mipmapMode == rhs.mipmapMode ) + && ( addressModeU == rhs.addressModeU ) + && ( addressModeV == rhs.addressModeV ) + && ( addressModeW == rhs.addressModeW ) + && ( mipLodBias == rhs.mipLodBias ) + && ( anisotropyEnable == rhs.anisotropyEnable ) + && ( maxAnisotropy == rhs.maxAnisotropy ) + && ( compareEnable == rhs.compareEnable ) + && ( compareOp == rhs.compareOp ) + && ( minLod == rhs.minLod ) + && ( maxLod == rhs.maxLod ) + && ( borderColor == rhs.borderColor ) + && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); + } + + bool operator!=( SamplerCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerCreateInfo; + + public: + const void* pNext = nullptr; + SamplerCreateFlags flags; + Filter magFilter; + Filter minFilter; + SamplerMipmapMode mipmapMode; + SamplerAddressMode addressModeU; + SamplerAddressMode addressModeV; + SamplerAddressMode addressModeW; + float mipLodBias; + Bool32 anisotropyEnable; + float maxAnisotropy; + Bool32 compareEnable; + CompareOp compareOp; + float minLod; + float maxLod; + BorderColor borderColor; + Bool32 unnormalizedCoordinates; + }; + static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); + enum class PipelineCreateFlagBits { eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, @@ -24130,7 +24432,8 @@ public: eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT + eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT, + eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT }; using FormatFeatureFlags = Flags; @@ -24149,7 +24452,7 @@ public: { enum { - allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) + allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) | VkFlags(FormatFeatureFlagBits::eFragmentDensityMapEXT) }; }; @@ -26707,7 +27010,8 @@ public: eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, - eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV + eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, + eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT }; using PipelineStageFlags = Flags; @@ -26726,7 +27030,7 @@ public: { enum { - allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) + allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) | VkFlags(PipelineStageFlagBits::eFragmentDensityProcessEXT) }; }; @@ -34259,7 +34563,8 @@ public: enum class SwapchainCreateFlagBitsKHR { eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, - eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR + eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, + eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR }; using SwapchainCreateFlagsKHR = Flags; @@ -34278,7 +34583,7 @@ public: { enum { - allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) + allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) | VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat) }; }; @@ -36363,7 +36668,8 @@ public: eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR, eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, - eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR + eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, + eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR }; struct PhysicalDeviceDriverPropertiesKHR @@ -48647,6 +48953,7 @@ public: 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 }; }; @@ -48716,8 +49023,16 @@ public: 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 }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -48803,16 +49118,6 @@ public: return "{}"; } - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags) - { - return "{}"; - } - VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) { return "(void)"; @@ -48963,16 +49268,6 @@ public: return "{}"; } - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags) - { - return "{}"; - } - VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) { return "(void)"; @@ -49297,6 +49592,7 @@ public: case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR"; case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR"; case ImageLayout::eShadingRateOptimalNV: return "ShadingRateOptimalNV"; + case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT"; default: return "invalid"; } } @@ -50294,6 +50590,11 @@ public: case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR: return "PhysicalDeviceVulkanMemoryModelFeaturesKHR"; case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT: return "PhysicalDevicePciBusInfoPropertiesEXT"; case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA"; + case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT: return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT: return "PhysicalDeviceFragmentDensityMapPropertiesEXT"; + case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT: return "RenderPassFragmentDensityMapCreateInfoEXT"; + case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT: return "PhysicalDeviceScalarBlockLayoutFeaturesEXT"; + case StructureType::eImageStencilUsageCreateInfoEXT: return "ImageStencilUsageCreateInfoEXT"; default: return "invalid"; } } @@ -50506,6 +50807,7 @@ public: case AccessFlagBits::eShadingRateImageReadNV: return "ShadingRateImageReadNV"; case AccessFlagBits::eAccelerationStructureReadNV: return "AccelerationStructureReadNV"; case AccessFlagBits::eAccelerationStructureWriteNV: return "AccelerationStructureWriteNV"; + case AccessFlagBits::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT"; default: return "invalid"; } } @@ -50541,6 +50843,7 @@ public: if (value & AccessFlagBits::eShadingRateImageReadNV) result += "ShadingRateImageReadNV | "; if (value & AccessFlagBits::eAccelerationStructureReadNV) result += "AccelerationStructureReadNV | "; if (value & AccessFlagBits::eAccelerationStructureWriteNV) result += "AccelerationStructureWriteNV | "; + if (value & AccessFlagBits::eFragmentDensityMapReadEXT) result += "FragmentDensityMapReadEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50668,6 +50971,7 @@ public: case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment"; case ImageUsageFlagBits::eInputAttachment: return "InputAttachment"; case ImageUsageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV"; + case ImageUsageFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT"; default: return "invalid"; } } @@ -50685,6 +50989,7 @@ public: if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | "; if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | "; if (value & ImageUsageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | "; + if (value & ImageUsageFlagBits::eFragmentDensityMapEXT) result += "FragmentDensityMapEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50706,6 +51011,7 @@ public: case ImageCreateFlagBits::eDisjoint: return "Disjoint"; case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV"; case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT"; + case ImageCreateFlagBits::eSubsampledEXT: return "SubsampledEXT"; default: return "invalid"; } } @@ -50728,6 +51034,43 @@ public: if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | "; if (value & ImageCreateFlagBits::eCornerSampledNV) result += "CornerSampledNV | "; if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | "; + if (value & ImageCreateFlagBits::eSubsampledEXT) result += "SubsampledEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits value) + { + switch (value) + { + case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT: return "FragmentDensityMapDynamicEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) result += "FragmentDensityMapDynamicEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits value) + { + switch (value) + { + case SamplerCreateFlagBits::eSubsampledEXT: return "SubsampledEXT"; + case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT: return "SubsampledCoarseReconstructionEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SamplerCreateFlagBits::eSubsampledEXT) result += "SubsampledEXT | "; + if (value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT) result += "SubsampledCoarseReconstructionEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -50826,6 +51169,7 @@ public: case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples"; case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG"; case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT"; + case FormatFeatureFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT"; default: return "invalid"; } } @@ -50858,6 +51202,7 @@ public: if (value & FormatFeatureFlagBits::eCositedChromaSamples) result += "CositedChromaSamples | "; if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | "; if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | "; + if (value & FormatFeatureFlagBits::eFragmentDensityMapEXT) result += "FragmentDensityMapEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -51063,6 +51408,7 @@ public: case PipelineStageFlagBits::eAccelerationStructureBuildNV: return "AccelerationStructureBuildNV"; case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV"; case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV"; + case PipelineStageFlagBits::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT"; default: return "invalid"; } } @@ -51096,6 +51442,7 @@ public: if (value & PipelineStageFlagBits::eAccelerationStructureBuildNV) result += "AccelerationStructureBuildNV | "; if (value & PipelineStageFlagBits::eTaskShaderNV) result += "TaskShaderNV | "; if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | "; + if (value & PipelineStageFlagBits::eFragmentDensityProcessEXT) result += "FragmentDensityProcessEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -51939,6 +52286,7 @@ public: { case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; case SwapchainCreateFlagBitsKHR::eProtected: return "Protected"; + case SwapchainCreateFlagBitsKHR::eMutableFormat: return "MutableFormat"; default: return "invalid"; } } @@ -51949,6 +52297,7 @@ public: std::string result; if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | "; if (value & SwapchainCreateFlagBitsKHR::eProtected) result += "Protected | "; + if (value & SwapchainCreateFlagBitsKHR::eMutableFormat) result += "MutableFormat | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -52218,6 +52567,7 @@ public: case DriverIdKHR::eImaginationProprietary: return "ImaginationProprietary"; case DriverIdKHR::eQualcommProprietary: return "QualcommProprietary"; case DriverIdKHR::eArmProprietary: return "ArmProprietary"; + case DriverIdKHR::eGooglePastel: return "GooglePastel"; default: return "invalid"; } } diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 22cd3e6..bdbf800 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 92 +#define VK_HEADER_VERSION 94 #define VK_NULL_HANDLE 0 @@ -454,6 +454,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, @@ -877,6 +882,7 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003, + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, @@ -1324,6 +1330,7 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, + VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, @@ -1347,6 +1354,7 @@ typedef enum VkImageUsageFlagBits { VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100, + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkImageUsageFlagBits; typedef VkFlags VkImageUsageFlags; @@ -1366,6 +1374,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, @@ -1450,6 +1459,7 @@ typedef enum VkPipelineStageFlagBits { VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineStageFlagBits; typedef VkFlags VkPipelineStageFlags; @@ -1549,6 +1559,11 @@ typedef enum VkBufferUsageFlagBits { } VkBufferUsageFlagBits; typedef VkFlags VkBufferUsageFlags; typedef VkFlags VkBufferViewCreateFlags; + +typedef enum VkImageViewCreateFlagBits { + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageViewCreateFlagBits; typedef VkFlags VkImageViewCreateFlags; typedef VkFlags VkShaderModuleCreateFlags; typedef VkFlags VkPipelineCacheCreateFlags; @@ -1615,6 +1630,12 @@ typedef VkFlags VkColorComponentFlags; typedef VkFlags VkPipelineDynamicStateCreateFlags; typedef VkFlags VkPipelineLayoutCreateFlags; typedef VkFlags VkShaderStageFlags; + +typedef enum VkSamplerCreateFlagBits { + VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, + VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSamplerCreateFlagBits; typedef VkFlags VkSamplerCreateFlags; typedef enum VkDescriptorSetLayoutCreateFlagBits { @@ -1675,6 +1696,7 @@ typedef enum VkAccessFlagBits { VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000, VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000, + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAccessFlagBits; typedef VkFlags VkAccessFlags; @@ -1731,10 +1753,6 @@ typedef enum VkStencilFaceFlagBits { } VkStencilFaceFlagBits; typedef VkFlags VkStencilFaceFlags; -typedef enum VkRenderPassCreateFlagBits { - VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassCreateFlagBits; - typedef struct VkApplicationInfo { VkStructureType sType; const void* pNext; @@ -4359,7 +4377,7 @@ typedef struct VkDescriptorUpdateTemplateEntry { typedef struct VkDescriptorUpdateTemplateCreateInfo { VkStructureType sType; - void* pNext; + const void* pNext; VkDescriptorUpdateTemplateCreateFlags flags; uint32_t descriptorUpdateEntryCount; const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; @@ -4798,6 +4816,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) typedef enum VkSwapchainCreateFlagBitsKHR { VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkSwapchainCreateFlagBitsKHR; typedef VkFlags VkSwapchainCreateFlagsKHR; @@ -6105,9 +6124,10 @@ typedef enum VkDriverIdKHR { VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7, VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8, VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9, + VK_DRIVER_ID_GOOGLE_PASTEL_KHR = 10, VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR, - VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, - VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_ARM_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1), + VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_GOOGLE_PASTEL_KHR, + VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_GOOGLE_PASTEL_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1), VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF } VkDriverIdKHR; @@ -6129,6 +6149,11 @@ typedef struct VkPhysicalDeviceDriverPropertiesKHR { +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + #define VK_KHR_vulkan_memory_model 1 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" @@ -8118,7 +8143,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( #define VK_NV_ray_tracing 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) -#define VK_NV_RAY_TRACING_SPEC_VERSION 2 +#define VK_NV_RAY_TRACING_SPEC_VERSION 3 #define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" #define VK_SHADER_UNUSED_NV (~0U) @@ -8808,6 +8833,46 @@ typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { +#define VK_EXT_fragment_density_map 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" + +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT; + + + +#define VK_EXT_scalar_block_layout 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; + + + #define VK_GOOGLE_hlsl_functionality1 1 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 0 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" @@ -8818,6 +8883,18 @@ typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" +#define VK_EXT_separate_stencil_usage 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" + +typedef struct VkImageStencilUsageCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfoEXT; + + + #ifdef __cplusplus } #endif diff --git a/registry/validusage.json b/registry/validusage.json index 84da76f..c2756dc 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.1.92", - "comment": "from git branch: master commit: 279452463adf97364575ea9e5bdf17e5b5a0a74c", - "date": "2018-11-12 16:55:13Z" + "api version": "1.1.94", + "comment": "from git branch: master commit: c24b84795f6c083df107d8639286881a23894679", + "date": "2018-11-27 18:23:26Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -198,7 +198,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, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, 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, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -334,7 +334,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, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDrawParameterFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceVariablePointerFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, or VkPhysicalDeviceVulkanMemoryModelFeaturesKHR" + "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, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDrawParameterFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceVariablePointerFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, or VkPhysicalDeviceVulkanMemoryModelFeaturesKHR" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -2988,33 +2988,33 @@ }, "VkRenderPassCreateInfo": { "core": [ - { - "vuid": "VUID-VkRenderPassCreateInfo-None-00832", - "text": " If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-attachment-00833", - "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags" - }, { "vuid": "VUID-VkRenderPassCreateInfo-attachment-00834", "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount" }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835", - "text": " The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED" - }, { "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-00836", "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL." }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-02511", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL." + }, { "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00837", - "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-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 source subpass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-srcSubpass-02517", + "text": " The srcSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-dstSubpass-02518", + "text": " The dstSubpass member of each element of pDependencies must be less than subpassCount" }, { "vuid": "VUID-VkRenderPassCreateInfo-sType-sType", @@ -3022,16 +3022,12 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo-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 VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo" + "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 VkRenderPassFragmentDensityMapCreateInfoEXT, VkRenderPassInputAttachmentAspectCreateInfo, or VkRenderPassMultiviewCreateInfo" }, { "vuid": "VUID-VkRenderPassCreateInfo-sType-unique", "text": " Each sType member in the pNext chain must be unique" }, - { - "vuid": "VUID-VkRenderPassCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkRenderPassCreateFlagBits values" - }, { "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-parameter", "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures" @@ -3068,7 +3064,7 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo-pNext-01963", - "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the aspectMask member of any element of pAspectReferences must only include aspects that are present in images of the format of the input attachment specified by the subpass and inputAttachment of the same element of pAspectReferences" + "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, for any element of the pInputAttachments member of any element of pSubpasses where the attachment member is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are present in images of the format specified by the element of pAttachments at attachment" } ], "(VK_VERSION_1_1,VK_KHR_multiview)": [ @@ -3083,6 +3079,26 @@ { "vuid": "VUID-VkRenderPassCreateInfo-pNext-01930", "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02512", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for any element of pDependencies with a dependencyFlags member that doesn’t include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02513", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, elements of its pViewMasks member must either all be 0, or all not be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02514", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and each element of its pViewMasks member is 0, the dependencyFlags member of each element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02515", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and each element of its pViewMasks member is 0, correlatedViewMaskCount must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02516", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, each element of its pViewMask member must not include a bit at a position greater than the value of VkPhysicalDeviceLimits::maxFramebufferLayers" } ] }, @@ -3110,6 +3126,38 @@ } ] }, + "VkRenderPassFragmentDensityMapCreateInfoEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02547", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must be less than VkRenderPassCreateInfo::attachmentCount" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02548", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must not be an element of VkSubpassDescription::pInputAttachments, VkSubpassDescription::pColorAttachments, VkSubpassDescription::pResolveAttachments, VkSubpassDescription::pDepthStencilAttachment, or VkSubpassDescription::pPreserveAttachments for any subpass" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02549", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, layout must be equal to VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a loadOp equal to VK_ATTACHMENT_LOAD_OP_LOAD or VK_ATTACHMENT_LOAD_OP_DONT_CARE." + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a storeOp equal to VK_ATTACHMENT_STORE_OP_DONT_CARE." + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-parameter", + "text": " fragmentDensityMapAttachment must be a valid VkAttachmentReference structure" + } + ] + }, "VkAttachmentDescription": { "core": [ { @@ -3230,10 +3278,6 @@ "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-01418", "text": " If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" }, - { - "vuid": "VUID-VkSubpassDescription-None-00852", - "text": " If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader" - }, { "vuid": "VUID-VkSubpassDescription-attachment-00853", "text": " The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" @@ -3243,8 +3287,8 @@ "text": " Each element of pPreserveAttachments must not also be an element of any other member of the subpass description" }, { - "vuid": "VUID-VkSubpassDescription-layout-00855", - "text": " If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout" + "vuid": "VUID-VkSubpassDescription-layout-02519", + "text": " If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout" }, { "vuid": "VUID-VkSubpassDescription-flags-parameter", @@ -3385,12 +3429,12 @@ ], "(VK_VERSION_1_1,VK_KHR_multiview)": [ { - "vuid": "VUID-VkSubpassDependency-dependencyFlags-00870", - "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL" + "vuid": "VUID-VkSubpassDependency-dependencyFlags-02520", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL" }, { - "vuid": "VUID-VkSubpassDependency-dependencyFlags-00871", - "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled" + "vuid": "VUID-VkSubpassDependency-dependencyFlags-02521", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL" }, { "vuid": "VUID-VkSubpassDependency-srcSubpass-00872", @@ -3451,12 +3495,12 @@ "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any given element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount" }, { - "vuid": "VUID-VkRenderPassCreateInfo2KHR-pPreserveAttachments-03052", - "text": " The value of any element of the pPreserveAttachments member in any given element of pSubpasses must not be VK_ATTACHMENT_UNUSED" + "vuid": "VUID-VkRenderPassCreateInfo2KHR-pAttachments-02522", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" }, { - "vuid": "VUID-VkRenderPassCreateInfo2KHR-pAttachments-03053", - "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL." + "vuid": "VUID-VkRenderPassCreateInfo2KHR-pAttachments-02523", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL." }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054", @@ -3486,6 +3530,22 @@ "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03060", "text": " For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT" }, + { + "vuid": "VUID-VkRenderPassCreateInfo2KHR-viewMask-02524", + "text": " The viewMask member must not include a bit at a position greater than the value of VkPhysicalDeviceLimits::maxFramebufferLayers" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2KHR-attachment-02525", + "text": " If the attachment member of any element of the pInputAttachments member of any element of pSubpasses is not VK_ATTACHMENT_UNUSED, the aspectMask member of that element of pInputAttachments must only include aspects that are present in images of the format specified by the element of pAttachments specified by attachment" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2KHR-srcSubpass-02526", + "text": " The srcSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2KHR-dstSubpass-02527", + "text": " The dstSubpass member of each element of pDependencies must be less than subpassCount" + }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR" @@ -3494,10 +3554,6 @@ "vuid": "VUID-VkRenderPassCreateInfo2KHR-pNext-pNext", "text": " pNext must be NULL" }, - { - "vuid": "VUID-VkRenderPassCreateInfo2KHR-flags-parameter", - "text": " flags must be a valid combination of VkRenderPassCreateFlagBits values" - }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pAttachments-parameter", "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2KHR structures" @@ -3518,12 +3574,6 @@ "vuid": "VUID-VkRenderPassCreateInfo2KHR-subpassCount-arraylength", "text": " subpassCount must be greater than 0" } - ], - "(VK_KHR_create_renderpass2)+(VK_EXT_transform_feedback)": [ - { - "vuid": "VUID-VkRenderPassCreateInfo2KHR-None-02348", - "text": " If any two subpasses activate transform feedback to the same bound transform feedback buffers a subpass dependency must be included (either directly or via some intermediate subpasses) between them" - } ] }, "VkAttachmentDescription2KHR": { @@ -3612,10 +3662,6 @@ "vuid": "VUID-VkSubpassDescription2KHR-pDepthStencilAttachment-03071", "text": " If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" }, - { - "vuid": "VUID-VkSubpassDescription2KHR-None-03072", - "text": " If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader" - }, { "vuid": "VUID-VkSubpassDescription2KHR-attachment-03073", "text": " The attachment member of any element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" @@ -3625,8 +3671,8 @@ "text": " Any given element of pPreserveAttachments must not also be an element of any other member of the subpass description" }, { - "vuid": "VUID-VkSubpassDescription2KHR-layout-03075", - "text": " If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout" + "vuid": "VUID-VkSubpassDescription2KHR-layout-02528", + "text": " If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout" }, { "vuid": "VUID-VkSubpassDescription2KHR-aspectMask-03175", @@ -3636,6 +3682,10 @@ "vuid": "VUID-VkSubpassDescription2KHR-aspectMask-03176", "text": " The aspectMask member of any element of pInputAttachments must not be 0" }, + { + "vuid": "VUID-VkSubpassDescription2KHR-aspectMask-02529", + "text": " The aspectMask member of each element of pInputAttachments must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, { "vuid": "VUID-VkSubpassDescription2KHR-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR" @@ -3760,6 +3810,10 @@ "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-02245", "text": " If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT" }, + { + "vuid": "VUID-VkSubpassDependency2KHR-viewOffset-02530", + "text": " If viewOffset is not equal to 0, srcSubpass must not be equal to dstSubpass" + }, { "vuid": "VUID-VkSubpassDependency2KHR-dependencyFlags-03092", "text": " If dependencyFlags does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, viewOffset must be 0" @@ -3898,10 +3952,6 @@ "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00881", "text": " Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass" }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00882", - "text": " Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension" - }, { "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00883", "text": " Each element of pAttachments must only specify a single mip level" @@ -3959,11 +4009,45 @@ "text": " Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice" } ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02552", + "text": " Each element of pAttachments that is used as a fragment density map attachment by renderPass must not have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT." + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02553", + "text": " If renderPass has a fragment density map attachment and non-subsample image feature is not enabled, each element of pAttachments must have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT unless that element is the fragment density map attachment." + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02554", + "text": " Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension except for any element that is referenced by fragmentDensityMapAttachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02555", + "text": " An element of pAttachments that is referenced by fragmentDensityMapAttachment must have a width at least as large as \\(\\lceil{\\frac{width}{maxFragmentDensityTexelSize_{width}}}\\rceil\\)" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02556", + "text": " An element of pAttachments that is referenced by fragmentDensityMapAttachment must have a height at least as large as \\(\\lceil{\\frac{height}{maxFragmentDensityTexelSize_{height}}}\\rceil\\)" + } + ], + "!(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00882", + "text": " Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension" + } + ], "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ { "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00891", "text": " Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format" } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02531", + "text": " If renderPass was specified with non-zero view masks, layers must be greater than or equal to the greatest position of any bit included in any of those view masks" + } ] }, "vkDestroyFramebuffer": { @@ -4022,7 +4106,11 @@ }, { "vuid": "VUID-vkCmdBeginRenderPass-srcStageMask-00901", - "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from." + "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-framebuffer-02532", + "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" }, { "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", @@ -4072,6 +4160,10 @@ "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03094", "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set" }, + { + "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03096", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, { "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03097", "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" @@ -4090,7 +4182,11 @@ }, { "vuid": "VUID-vkCmdBeginRenderPass2KHR-srcStageMask-03101", - "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from." + "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2KHR-framebuffer-02533", + "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" }, { "vuid": "VUID-vkCmdBeginRenderPass2KHR-commandBuffer-parameter", @@ -4120,18 +4216,6 @@ "vuid": "VUID-vkCmdBeginRenderPass2KHR-bufferlevel", "text": " commandBuffer must be a primary VkCommandBuffer" } - ], - "(VK_KHR_create_renderpass2)+!(VK_KHR_maintenance2)": [ - { - "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03095", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - } - ], - "(VK_KHR_create_renderpass2)+(VK_KHR_maintenance2)": [ - { - "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03096", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - } ] }, "VkRenderPassBeginInfo": { @@ -4140,10 +4224,6 @@ "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00902", "text": " clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR" }, - { - "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00903", - "text": " If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount valid VkClearValue unions" - }, { "vuid": "VUID-VkRenderPassBeginInfo-renderPass-00904", "text": " renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer." @@ -4168,6 +4248,10 @@ "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "text": " framebuffer must be a valid VkFramebuffer handle" }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pClearValues-parameter", + "text": " If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount VkClearValue unions" + }, { "vuid": "VUID-VkRenderPassBeginInfo-commonparent", "text": " Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice" @@ -5205,7 +5289,7 @@ ], "(VK_EXT_depth_range_unrestricted)": [ { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510", "text": " If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" } ], @@ -6316,6 +6400,18 @@ } ] }, + "VkMemoryWin32HandlePropertiesKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryWin32HandlePropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR" + }, + { + "vuid": "VUID-VkMemoryWin32HandlePropertiesKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, "VkImportMemoryFdInfoKHR": { "(VK_KHR_external_memory_fd)": [ { @@ -7092,11 +7188,11 @@ }, { "vuid": "VUID-VkBufferViewCreateInfo-range-00929", - "text": " If range is not equal to VK_WHOLE_SIZE, range must be a multiple of the element size of format" + "text": " If range is not equal to VK_WHOLE_SIZE, range must be an integer multiple of the texel block size of format" }, { "vuid": "VUID-VkBufferViewCreateInfo-range-00930", - "text": " If range is not equal to VK_WHOLE_SIZE, range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" + "text": " If range is not equal to VK_WHOLE_SIZE, range divided by the texel block size of format, multiplied by the number of texels per texel block for that format (as defined in the Compatible Formats table), must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" }, { "vuid": "VUID-VkBufferViewCreateInfo-offset-00931", @@ -7356,7 +7452,7 @@ }, { "vuid": "VUID-VkImageCreateInfo-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 VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfoKHR, or VkImageSwapchainCreateInfoKHR" + "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 VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfoKHR, VkImageStencilUsageCreateInfoEXT, or VkImageSwapchainCreateInfoKHR" }, { "vuid": "VUID-VkImageCreateInfo-sType-unique", @@ -7451,6 +7547,40 @@ "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, tiling must be VK_IMAGE_TILING_OPTIMAL." } ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-02557", + "text": " If flags contains VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-02558", + "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, usage must not contain VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-02559", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \\(\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-02560", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02565", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, tiling must be VK_IMAGE_TILING_OPTIMAL" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02566", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02567", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02568", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, mipLevels must be 1" + } + ], "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ { "vuid": "VUID-VkImageCreateInfo-flags-00950", @@ -7513,8 +7643,20 @@ ], "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { - "vuid": "VUID-VkImageCreateInfo-format-01574", - "text": " If the image format is one of those listed in Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views:" + "vuid": "VUID-VkImageCreateInfo-format-02561", + "text": " If the image format is one of those listed in Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, then mipLevels must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02562", + "text": " If the image format is one of those listed in Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, samples must be VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02563", + "text": " If the image format is one of those listed in Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02564", + "text": " If the image format is one of those listed in Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views, arrayLayers must be 1" }, { "vuid": "VUID-VkImageCreateInfo-imageCreateFormatFeatures-02260", @@ -7545,6 +7687,28 @@ "text": " If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format" } ], + "(VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-02534", + "text": " If format is a depth-stencil format and the pNext chain contains an instance of VkImageStencilUsageCreateInfoEXT, then its stencilUsage member must only include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT if usage also includes it" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02535", + "text": " If format is a depth-stencil format and the pNext chain contains an instance of VkImageStencilUsageCreateInfoEXT, then its stencilUsage member must only include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT if usage also includes it" + }, + { + "vuid": "VUID-VkImageCreateInfo-Format-02536", + "text": " If Format is a depth-stencil format and the pNext chain contains an instance of VkImageStencilUsageCreateInfoEXT with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02537", + "text": " If format is a depth-stencil format and the pNext chain contains an instance of VkImageStencilUsageCreateInfoEXT with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02538", + "text": " If the multisampled storage images feature is not enabled, format is a depth-stencil format and the pNext chain contains an instance of VkImageStencilUsageCreateInfoEXT with its stencilUsage including VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" + } + ], "(VK_NV_corner_sampled_image)": [ { "vuid": "VUID-VkImageCreateInfo-flags-02050", @@ -7578,6 +7742,26 @@ } ] }, + "VkImageStencilUsageCreateInfoEXT": { + "(VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-02539", + "text": " If stencilUsage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-parameter", + "text": " stencilUsage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-requiredbitmask", + "text": " stencilUsage must not be 0" + } + ] + }, "VkDedicatedAllocationImageCreateInfoNV": { "(VK_NV_dedicated_allocation)": [ { @@ -7953,8 +8137,8 @@ "text": " Each sType member in the pNext chain must be unique" }, { - "vuid": "VUID-VkImageViewCreateInfo-flags-zerobitmask", - "text": " flags must be 0" + "vuid": "VUID-VkImageViewCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkImageViewCreateFlagBits values" }, { "vuid": "VUID-VkImageViewCreateInfo-image-parameter", @@ -7999,24 +8183,42 @@ "text": " If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the extent.depth specified in VkImageCreateInfo when image was created" } ], - "!(VK_NV_shading_rate_image)": [ + "!(VK_EXT_fragment_density_map)+!(VK_NV_shading_rate_image)": [ { "vuid": "VUID-VkImageViewCreateInfo-image-01007", "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" } ], - "(VK_NV_shading_rate_image)": [ + "!(VK_EXT_fragment_density_map)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-VkImageViewCreateInfo-image-02085", "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_EXT_fragment_density_map)+!(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02569", + "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02570", + "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, or VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02571", + "text": " If image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, subresourceRange.levelCount must be 1" }, { - "vuid": "VUID-VkImageViewCreateInfo-image-02086", - "text": " If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + "vuid": "VUID-VkImageViewCreateInfo-flags-02572", + "text": " If dynamic fragment density map feature is not enabled, flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT" }, { - "vuid": "VUID-VkImageViewCreateInfo-image-02087", - "text": " If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT" + "vuid": "VUID-VkImageViewCreateInfo-image-02573", + "text": " If dynamic fragment density map feature is not enabled and image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, flags must not contain any of VK_IMAGE_CREATE_PROTECTED_BIT, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" } ], "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ @@ -8096,6 +8298,16 @@ "vuid": "VUID-VkImageViewCreateInfo-image-02401", "text": " If image has an external format, all members of components must be VK_COMPONENT_SWIZZLE_IDENTITY." } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02086", + "text": " If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02087", + "text": " If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT" + } ] }, "VkImageViewUsageCreateInfo": { @@ -9441,8 +9653,8 @@ "text": " Each sType member in the pNext chain must be unique" }, { - "vuid": "VUID-VkSamplerCreateInfo-flags-zerobitmask", - "text": " flags must be 0" + "vuid": "VUID-VkSamplerCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkSamplerCreateFlagBits values" }, { "vuid": "VUID-VkSamplerCreateInfo-magFilter-parameter", @@ -9502,6 +9714,36 @@ "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01423", "text": " If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02574", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minFilter and magFilter must be equal." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02575", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02576", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minLod and maxLod must be zero." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02577", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02578", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then anisotropyEnable must be VK_FALSE." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02579", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then compareEnable must be VK_FALSE." + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02580", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then unnormalizedCoordinates must be VK_FALSE." + } ] }, "VkSamplerReductionModeCreateInfoEXT": { @@ -9615,8 +9857,24 @@ "text": " format must represent unsigned normalized values (i.e. the format must be a UNORM format)" }, { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-None-01654", - "text": " If the format has a _422 or _420 suffix:" + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02581", + "text": " If the format has a _422 or _420 suffix, then components.g must be VK_COMPONENT_SWIZZLE_IDENTITY" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02582", + "text": " If the format has a _422 or _420 suffix, then components.a must be VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ONE, or VK_COMPONENT_SWIZZLE_ZERO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02583", + "text": " If the format has a _422 or _420 suffix, then components.r must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_B" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02584", + "text": " If the format has a _422 or _420 suffix, then components.b must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_R" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02585", + "text": " If the format has a _422 or _420 suffix, and if either components.r or components.b is VK_COMPONENT_SWIZZLE_IDENTITY, both values must be VK_COMPONENT_SWIZZLE_IDENTITY" }, { "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", @@ -12127,7 +12385,7 @@ ], "!(VK_EXT_depth_range_unrestricted)": [ { - "vuid": "VUID-VkClearDepthStencilValue-depth-00022", + "vuid": "VUID-VkClearDepthStencilValue-depth-02506", "text": " depth must be between 0.0 and 1.0, inclusive" } ] @@ -12500,7 +12758,7 @@ }, { "vuid": "VUID-vkCmdCopyImage-srcImage-00135", - "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined below" + "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined above" } ], "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ @@ -12514,7 +12772,7 @@ }, { "vuid": "VUID-vkCmdCopyImage-srcImage-01548", - "text": " If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined below" + "text": " If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined above" }, { "vuid": "VUID-vkCmdCopyImage-None-01549", @@ -12558,6 +12816,12 @@ "vuid": "VUID-vkCmdCopyImage-commandBuffer-01827", "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyImage-dstImage-02542", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } ] }, "VkImageCopy": { @@ -12916,6 +13180,12 @@ "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01830", "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-02543", + "text": " dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } ] }, "vkCmdCopyImageToBuffer": { @@ -13040,13 +13310,19 @@ "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833", "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-02544", + "text": " srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } ] }, "VkBufferImageCopy": { "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkBufferImageCopy-bufferOffset-00193", - "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format, then bufferOffset must be a multiple of the format’s element size" + "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format, then bufferOffset must be a multiple of the format’s texel block size." }, { "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00203", @@ -13080,7 +13356,7 @@ "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkBufferImageCopy-bufferOffset-01558", - "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format or a multi-planar format, then bufferOffset must be a multiple of the format’s element size" + "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format or a multi-planar format, then bufferOffset must be a multiple of the format’s texel block size." }, { "vuid": "VUID-VkBufferImageCopy-bufferOffset-01559", @@ -13372,6 +13648,12 @@ "vuid": "VUID-vkCmdBlitImage-commandBuffer-01836", "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdBlitImage-dstImage-02545", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } ] }, "VkImageBlit": { @@ -13586,6 +13868,12 @@ "vuid": "VUID-vkCmdResolveImage-commandBuffer-01839", "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdResolveImage-dstImage-02546", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } ] }, "VkImageResolve": { @@ -13770,6 +14058,12 @@ "vuid": "VUID-vkCmdBindIndexBuffer-commonparent", "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBindIndexBuffer-indexType-02507", + "text": " indexType must not be VK_INDEX_TYPE_NONE_NV." + } ] }, "vkCmdDraw": { @@ -15309,6 +15603,22 @@ { "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-offset-01984", "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-flags-parameter", + "text": " flags must be a valid combination of VkConditionalRenderingFlagBitsEXT values" } ] }, @@ -16461,11 +16771,11 @@ ], "!(VK_EXT_depth_range_unrestricted)": [ { - "vuid": "VUID-VkViewport-minDepth-01234", + "vuid": "VUID-VkViewport-minDepth-02540", "text": " minDepth must be between 0.0 and 1.0, inclusive" }, { - "vuid": "VUID-VkViewport-maxDepth-01235", + "vuid": "VUID-VkViewport-maxDepth-02541", "text": " maxDepth must be between 0.0 and 1.0, inclusive" } ] @@ -17263,11 +17573,11 @@ ], "!(VK_EXT_depth_range_unrestricted)": [ { - "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", + "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-02508", "text": " minDepthBounds must be between 0.0 and 1.0, inclusive" }, { - "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", + "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-02509", "text": " maxDepthBounds must be between 0.0 and 1.0, inclusive" } ] @@ -20310,7 +20620,7 @@ }, { "vuid": "VUID-VkSwapchainCreateInfoKHR-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 VkDeviceGroupSwapchainCreateInfoKHR or VkSwapchainCounterCreateInfoEXT" + "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 VkDeviceGroupSwapchainCreateInfoKHR, VkImageFormatListCreateInfoKHR, or VkSwapchainCounterCreateInfoEXT" }, { "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-unique", @@ -20406,6 +20716,12 @@ "vuid": "VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_swapchain_mutable_format)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-03168", + "text": " If flags contains VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR then the pNext chain must contain an instance of VkImageFormatListCreateInfoKHR with a viewFormatCount greater than zero and pViewFormats must have an element equal to imageFormat" + } ] }, "VkDeviceGroupSwapchainCreateInfoKHR": { @@ -21026,7 +21342,7 @@ }, { "vuid": "VUID-vkCmdTraceRaysNV-None-02481", - "text": " If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." + "text": " If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT." }, { "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-parameter", @@ -21064,7 +21380,7 @@ "(VK_NV_ray_tracing)+(VK_IMG_filter_cubic)": [ { "vuid": "VUID-vkCmdTraceRaysNV-None-02482", - "text": " If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG." }, { "vuid": "VUID-vkCmdTraceRaysNV-None-02483", @@ -21548,6 +21864,22 @@ } ] }, + "VkPhysicalDeviceFragmentDensityMapFeaturesEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT": { + "(VK_EXT_scalar_block_layout)": [ + { + "vuid": "VUID-VkPhysicalDeviceScalarBlockLayoutFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT" + } + ] + }, "VkPhysicalDevicePushDescriptorPropertiesKHR": { "(VK_KHR_push_descriptor)": [ { @@ -21684,6 +22016,14 @@ } ] }, + "VkPhysicalDeviceFragmentDensityMapPropertiesEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT" + } + ] + }, "VkPhysicalDeviceShaderCorePropertiesAMD": { "(VK_AMD_shader_core_properties)": [ { @@ -21922,7 +22262,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-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 VkImageFormatListCreateInfoKHR, VkPhysicalDeviceExternalImageFormatInfo, or VkPhysicalDeviceImageDrmFormatModifierInfoEXT" + "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 VkImageFormatListCreateInfoKHR, VkImageStencilUsageCreateInfoEXT, VkPhysicalDeviceExternalImageFormatInfo, or VkPhysicalDeviceImageDrmFormatModifierInfoEXT" }, { "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-sType-unique", diff --git a/registry/vk.xml b/registry/vk.xml index b0ce893..86e0589 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -146,7 +146,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 92 +#define VK_HEADER_VERSION 94 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -187,7 +187,7 @@ server. typedef VkFlags VkFramebufferCreateFlags; typedef VkFlags VkQueryPoolCreateFlags; typedef VkFlags VkRenderPassCreateFlags; - typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkSamplerCreateFlags; typedef VkFlags VkPipelineLayoutCreateFlags; typedef VkFlags VkPipelineCacheCreateFlags; typedef VkFlags VkPipelineDepthStencilStateCreateFlags; @@ -214,7 +214,7 @@ server. typedef VkFlags VkShaderStageFlags; typedef VkFlags VkImageUsageFlags; typedef VkFlags VkImageCreateFlags; - typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkImageViewCreateFlags; typedef VkFlags VkPipelineCreateFlags; typedef VkFlags VkColorComponentFlags; typedef VkFlags VkFenceCreateFlags; @@ -406,6 +406,7 @@ server. + @@ -1253,7 +1254,7 @@ server. VkFramebuffer framebuffer VkRect2D renderArea uint32_t clearValueCount - const VkClearValue* pClearValues + const VkClearValue* pClearValues float float32[4] @@ -1312,7 +1313,7 @@ server. VkStructureType sType const void* pNext - VkRenderPassCreateFlags flags + VkRenderPassCreateFlags flags uint32_t attachmentCount const VkAttachmentDescription* pAttachments uint32_t subpassCount @@ -2441,7 +2442,7 @@ server. VkStructureType sType - void* pNext + const void* pNext VkDescriptorUpdateTemplateCreateFlags flags uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template @@ -2883,7 +2884,7 @@ server. uint32_t coverageModulationTableCount const float* pCoverageModulationTable - + VkStructureType sType const void* pNext uint32_t viewFormatCount @@ -3170,7 +3171,7 @@ server. VkStructureType sType const void* pNext - VkRenderPassCreateFlags flags + VkRenderPassCreateFlags flags uint32_t attachmentCount const VkAttachmentDescription2KHR* pAttachments uint32_t subpassCount @@ -3585,11 +3586,40 @@ server. void* pNext uint64_t drmFormatModifier + + VkStructureType sType + const void* pNext + VkImageUsageFlags stencilUsage + VkStructureType sType const void* pNext VkMemoryOverallocationBehaviorAMD overallocationBehavior + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMap + VkBool32 fragmentDensityMapDynamic + VkBool32 fragmentDensityMapNonSubsampledImages + + + VkStructureType sType + void* pNext + VkExtent2D minFragmentDensityTexelSize + VkExtent2D maxFragmentDensityTexelSize + VkBool32 fragmentDensityInvocations + + + VkStructureType sType + const void* pNext + VkAttachmentReference fragmentDensityMapAttachment + + + VkStructureType sType + void* pNext + VkBool32 scalarBlockLayout + Vulkan enumerant (token) definitions @@ -4246,6 +4276,10 @@ server. + + + + @@ -4698,6 +4732,7 @@ server. + @@ -7176,7 +7211,6 @@ server. - @@ -7780,14 +7814,36 @@ server. - - + + + + + + + + + + + + + - - + + + + + + + + + + + + + @@ -9478,7 +9534,7 @@ server. - + @@ -9807,10 +9863,11 @@ server. - + - - + + + @@ -9953,15 +10010,25 @@ server. - + - - - - - - - + + + + + + + + + + + + + + + + + @@ -9977,10 +10044,12 @@ server. - + - - + + + + @@ -10127,10 +10196,12 @@ server. - + - - + + + +