organicmaps/Vulkan-Headers
13
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers.git synced 2025-04-05 13:14:58 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

headers: Update to Vulkan header version 1.1.97

Browse source 
Updated:
- `include/vulkan/vulkan.h`
- `include/vulkan/vulkan.hpp`
- `include/vulkan/vulkan_android.h`
- `include/vulkan/vulkan_core.h`
- `include/vulkan/vulkan_fuchsia.h`
- `include/vulkan/vulkan_ios.h`
- `include/vulkan/vulkan_macos.h`
- `include/vulkan/vulkan_vi.h`
- `include/vulkan/vulkan_wayland.h`
- `include/vulkan/vulkan_win32.h`
- `include/vulkan/vulkan_xcb.h`
- `include/vulkan/vulkan_xlib.h`
- `include/vulkan/vulkan_xlib_xrandr.h`
- `registry/cgenerator.py`
- `registry/generator.py`
- `registry/genvk.py`
- `registry/reg.py`
- `registry/validusage.json`
- `registry/vk.xml`
This commit is contained in:
Shannon McPherson 2019-01-07 15:55:41 -07:00
parent f54e45b923
commit b0d6277a79
19 changed files with 1288 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/vulkan/vulkan.h
View file

@ -2,7 +2,7 @@
#define VULKAN_H_ 1
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

769
include/vulkan/vulkan.hpp
View file

@ -1,4 +1,4 @@
// Copyright (c) 2015-2018 The Khronos Group Inc.
// Copyright (c) 2015-2019 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@ -70,7 +70,7 @@
#undef MemoryBarrier
#endif
static_assert( VK_HEADER_VERSION == 96 , "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 97 , "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
@ -631,7 +631,8 @@ namespace VULKAN_HPP_NAMESPACE
eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT,
eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT
};
VULKAN_HPP_INLINE std::string to_string(Result value)
@ -668,6 +669,7 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT";
case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
case Result::eErrorInvalidDeviceAddressEXT: return "ErrorInvalidDeviceAddressEXT";
default: return "invalid";
}
}
@ -936,6 +938,14 @@ namespace VULKAN_HPP_NAMESPACE
NotPermittedEXTError( char const * message )
: SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
};
class InvalidDeviceAddressEXTError : public SystemError
{
public:
InvalidDeviceAddressEXTError( std::string const& message )
: SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), message ) {}
InvalidDeviceAddressEXTError( char const * message )
: SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), message ) {}
};
VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
{
@ -964,6 +974,7 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError ( message );
case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message );
case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message );
case Result::eErrorInvalidDeviceAddressEXT: throw InvalidDeviceAddressEXTError ( message );
default: throw SystemError( make_error_code( result ) );
}
}
@ -1936,6 +1947,10 @@ public:
return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties);
}
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo ) const
{
return ::vkGetBufferDeviceAddressEXT( device, pInfo);
}
void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const
{
return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements);
@ -2627,6 +2642,8 @@ public:
using DeviceSize = uint64_t;
using DeviceAddress = uint64_t;
enum class FramebufferCreateFlagBits
{
};
@ -9482,6 +9499,8 @@ public:
ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR,
ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR,
eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR,
ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
@ -9498,7 +9517,14 @@ public:
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
ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT,
eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT,
eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT,
eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
};
struct ApplicationInfo
@ -21461,6 +21487,361 @@ public:
};
static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceMemoryBudgetPropertiesEXT
{
operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this);
}
operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &()
{
return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this);
}
bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 )
&& ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 );
}
bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
public:
void* pNext = nullptr;
DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
};
static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceMemoryPriorityFeaturesEXT
{
PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = 0 )
: memoryPriority( memoryPriority_ )
{
}
PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) );
}
PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) );
return *this;
}
PhysicalDeviceMemoryPriorityFeaturesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
PhysicalDeviceMemoryPriorityFeaturesEXT& setMemoryPriority( Bool32 memoryPriority_ )
{
memoryPriority = memoryPriority_;
return *this;
}
operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this);
}
operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &()
{
return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this);
}
bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( memoryPriority == rhs.memoryPriority );
}
bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
public:
void* pNext = nullptr;
Bool32 memoryPriority;
};
static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" );
struct MemoryPriorityAllocateInfoEXT
{
MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
: priority( priority_ )
{
}
MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) );
}
MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) );
return *this;
}
MemoryPriorityAllocateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
MemoryPriorityAllocateInfoEXT& setPriority( float priority_ )
{
priority = priority_;
return *this;
}
operator VkMemoryPriorityAllocateInfoEXT const&() const
{
return *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(this);
}
operator VkMemoryPriorityAllocateInfoEXT &()
{
return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this);
}
bool operator==( MemoryPriorityAllocateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( priority == rhs.priority );
}
bool operator!=( MemoryPriorityAllocateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
public:
const void* pNext = nullptr;
float priority;
};
static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceBufferAddressFeaturesEXT
{
PhysicalDeviceBufferAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0,
Bool32 bufferDeviceAddressCaptureReplay_ = 0,
Bool32 bufferDeviceAddressMultiDevice_ = 0 )
: bufferDeviceAddress( bufferDeviceAddress_ )
, bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
, bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
{
}
PhysicalDeviceBufferAddressFeaturesEXT( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) );
}
PhysicalDeviceBufferAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) );
return *this;
}
PhysicalDeviceBufferAddressFeaturesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
PhysicalDeviceBufferAddressFeaturesEXT& setBufferDeviceAddress( Bool32 bufferDeviceAddress_ )
{
bufferDeviceAddress = bufferDeviceAddress_;
return *this;
}
PhysicalDeviceBufferAddressFeaturesEXT& setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ )
{
bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_;
return *this;
}
PhysicalDeviceBufferAddressFeaturesEXT& setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ )
{
bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_;
return *this;
}
operator VkPhysicalDeviceBufferAddressFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceBufferAddressFeaturesEXT*>(this);
}
operator VkPhysicalDeviceBufferAddressFeaturesEXT &()
{
return *reinterpret_cast<VkPhysicalDeviceBufferAddressFeaturesEXT*>(this);
}
bool operator==( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( bufferDeviceAddress == rhs.bufferDeviceAddress )
&& ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay )
&& ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
}
bool operator!=( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::ePhysicalDeviceBufferAddressFeaturesEXT;
public:
void* pNext = nullptr;
Bool32 bufferDeviceAddress;
Bool32 bufferDeviceAddressCaptureReplay;
Bool32 bufferDeviceAddressMultiDevice;
};
static_assert( sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferAddressFeaturesEXT ), "struct and wrapper have different size!" );
struct BufferDeviceAddressInfoEXT
{
BufferDeviceAddressInfoEXT( Buffer buffer_ = Buffer() )
: buffer( buffer_ )
{
}
BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) );
}
BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) );
return *this;
}
BufferDeviceAddressInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
BufferDeviceAddressInfoEXT& setBuffer( Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
operator VkBufferDeviceAddressInfoEXT const&() const
{
return *reinterpret_cast<const VkBufferDeviceAddressInfoEXT*>(this);
}
operator VkBufferDeviceAddressInfoEXT &()
{
return *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this);
}
bool operator==( BufferDeviceAddressInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( buffer == rhs.buffer );
}
bool operator!=( BufferDeviceAddressInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
public:
const void* pNext = nullptr;
Buffer buffer;
};
static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "struct and wrapper have different size!" );
struct BufferDeviceAddressCreateInfoEXT
{
BufferDeviceAddressCreateInfoEXT( DeviceSize deviceAddress_ = 0 )
: deviceAddress( deviceAddress_ )
{
}
BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) );
}
BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs )
{
memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) );
return *this;
}
BufferDeviceAddressCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
BufferDeviceAddressCreateInfoEXT& setDeviceAddress( DeviceSize deviceAddress_ )
{
deviceAddress = deviceAddress_;
return *this;
}
operator VkBufferDeviceAddressCreateInfoEXT const&() const
{
return *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(this);
}
operator VkBufferDeviceAddressCreateInfoEXT &()
{
return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this);
}
bool operator==( BufferDeviceAddressCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( deviceAddress == rhs.deviceAddress );
}
bool operator!=( BufferDeviceAddressCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
public:
const void* pNext = nullptr;
DeviceSize deviceAddress;
};
static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" );
enum class SubpassContents
{
eInline = VK_SUBPASS_CONTENTS_INLINE,
@ -23106,7 +23487,8 @@ public:
eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV,
eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT
};
using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
@ -23125,7 +23507,7 @@ public:
{
enum
{
allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV)
allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV) | VkFlags(BufferUsageFlagBits::eShaderDeviceAddressEXT)
};
};
@ -23134,7 +23516,8 @@ public:
eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
eProtected = VK_BUFFER_CREATE_PROTECTED_BIT
eProtected = VK_BUFFER_CREATE_PROTECTED_BIT,
eDeviceAddressCaptureReplayEXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT
};
using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
@ -23153,7 +23536,7 @@ public:
{
enum
{
allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected)
allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected) | VkFlags(BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT)
};
};
@ -31116,6 +31499,113 @@ public:
};
static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
enum class ValidationFeatureEnableEXT
{
eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT
};
enum class ValidationFeatureDisableEXT
{
eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,
eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT,
eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT,
eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT,
eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT,
eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT,
eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT
};
struct ValidationFeaturesEXT
{
ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
uint32_t disabledValidationFeatureCount_ = 0,
const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
: enabledValidationFeatureCount( enabledValidationFeatureCount_ )
, pEnabledValidationFeatures( pEnabledValidationFeatures_ )
, disabledValidationFeatureCount( disabledValidationFeatureCount_ )
, pDisabledValidationFeatures( pDisabledValidationFeatures_ )
{
}
ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) );
}
ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs )
{
memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) );
return *this;
}
ValidationFeaturesEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
ValidationFeaturesEXT& setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ )
{
enabledValidationFeatureCount = enabledValidationFeatureCount_;
return *this;
}
ValidationFeaturesEXT& setPEnabledValidationFeatures( const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ )
{
pEnabledValidationFeatures = pEnabledValidationFeatures_;
return *this;
}
ValidationFeaturesEXT& setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ )
{
disabledValidationFeatureCount = disabledValidationFeatureCount_;
return *this;
}
ValidationFeaturesEXT& setPDisabledValidationFeatures( const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ )
{
pDisabledValidationFeatures = pDisabledValidationFeatures_;
return *this;
}
operator VkValidationFeaturesEXT const&() const
{
return *reinterpret_cast<const VkValidationFeaturesEXT*>(this);
}
operator VkValidationFeaturesEXT &()
{
return *reinterpret_cast<VkValidationFeaturesEXT*>(this);
}
bool operator==( ValidationFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount )
&& ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures )
&& ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount )
&& ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures );
}
bool operator!=( ValidationFeaturesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eValidationFeaturesEXT;
public:
const void* pNext = nullptr;
uint32_t enabledValidationFeatureCount;
const ValidationFeatureEnableEXT* pEnabledValidationFeatures;
uint32_t disabledValidationFeatureCount;
const ValidationFeatureDisableEXT* pDisabledValidationFeatures;
};
static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" );
enum class SubgroupFeatureFlagBits
{
eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
@ -37186,6 +37676,154 @@ public:
};
static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
enum class ResolveModeFlagBitsKHR
{
eNone = VK_RESOLVE_MODE_NONE_KHR,
eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR,
eAverage = VK_RESOLVE_MODE_AVERAGE_BIT_KHR,
eMin = VK_RESOLVE_MODE_MIN_BIT_KHR,
eMax = VK_RESOLVE_MODE_MAX_BIT_KHR
};
using ResolveModeFlagsKHR = Flags<ResolveModeFlagBitsKHR, VkResolveModeFlagsKHR>;
VULKAN_HPP_INLINE ResolveModeFlagsKHR operator|( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
{
return ResolveModeFlagsKHR( bit0 ) | bit1;
}
VULKAN_HPP_INLINE ResolveModeFlagsKHR operator~( ResolveModeFlagBitsKHR bits )
{
return ~( ResolveModeFlagsKHR( bits ) );
}
template <> struct FlagTraits<ResolveModeFlagBitsKHR>
{
enum
{
allFlags = VkFlags(ResolveModeFlagBitsKHR::eNone) | VkFlags(ResolveModeFlagBitsKHR::eSampleZero) | VkFlags(ResolveModeFlagBitsKHR::eAverage) | VkFlags(ResolveModeFlagBitsKHR::eMin) | VkFlags(ResolveModeFlagBitsKHR::eMax)
};
};
struct PhysicalDeviceDepthStencilResolvePropertiesKHR
{
operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this);
}
operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR &()
{
return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this);
}
bool operator==( PhysicalDeviceDepthStencilResolvePropertiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( supportedDepthResolveModes == rhs.supportedDepthResolveModes )
&& ( supportedStencilResolveModes == rhs.supportedStencilResolveModes )
&& ( independentResolveNone == rhs.independentResolveNone )
&& ( independentResolve == rhs.independentResolve );
}
bool operator!=( PhysicalDeviceDepthStencilResolvePropertiesKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR;
public:
void* pNext = nullptr;
ResolveModeFlagsKHR supportedDepthResolveModes;
ResolveModeFlagsKHR supportedStencilResolveModes;
Bool32 independentResolveNone;
Bool32 independentResolve;
};
static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "struct and wrapper have different size!" );
struct SubpassDescriptionDepthStencilResolveKHR
{
SubpassDescriptionDepthStencilResolveKHR( ResolveModeFlagBitsKHR depthResolveMode_ = ResolveModeFlagBitsKHR::eNone,
ResolveModeFlagBitsKHR stencilResolveMode_ = ResolveModeFlagBitsKHR::eNone,
const AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
: depthResolveMode( depthResolveMode_ )
, stencilResolveMode( stencilResolveMode_ )
, pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
{
}
SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
{
memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) );
}
SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
{
memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) );
return *this;
}
SubpassDescriptionDepthStencilResolveKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
SubpassDescriptionDepthStencilResolveKHR& setDepthResolveMode( ResolveModeFlagBitsKHR depthResolveMode_ )
{
depthResolveMode = depthResolveMode_;
return *this;
}
SubpassDescriptionDepthStencilResolveKHR& setStencilResolveMode( ResolveModeFlagBitsKHR stencilResolveMode_ )
{
stencilResolveMode = stencilResolveMode_;
return *this;
}
SubpassDescriptionDepthStencilResolveKHR& setPDepthStencilResolveAttachment( const AttachmentReference2KHR* pDepthStencilResolveAttachment_ )
{
pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_;
return *this;
}
operator VkSubpassDescriptionDepthStencilResolveKHR const&() const
{
return *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolveKHR*>(this);
}
operator VkSubpassDescriptionDepthStencilResolveKHR &()
{
return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this);
}
bool operator==( SubpassDescriptionDepthStencilResolveKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( depthResolveMode == rhs.depthResolveMode )
&& ( stencilResolveMode == rhs.stencilResolveMode )
&& ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment );
}
bool operator!=( SubpassDescriptionDepthStencilResolveKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR;
public:
const void* pNext = nullptr;
ResolveModeFlagBitsKHR depthResolveMode;
ResolveModeFlagBitsKHR stencilResolveMode;
const AttachmentReference2KHR* pDepthStencilResolveAttachment;
};
static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" );
enum class ShadingRatePaletteEntryNV
{
eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
@ -42174,6 +42812,13 @@ public:
ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
@ -45765,6 +46410,19 @@ public:
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const
{
return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfoEXT*>( pInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d ) const
{
return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfoEXT*>( &info ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Device,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
@ -46120,6 +46778,8 @@ public:
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
StructureChain<X, Y, Z...> getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
@ -46127,6 +46787,8 @@ public:
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
StructureChain<X, Y, Z...> getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
@ -47299,6 +47961,14 @@ public:
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return memoryProperties;
}
template <typename X, typename Y, typename ...Z, typename Dispatch>
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
@ -47314,6 +47984,14 @@ public:
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return memoryProperties;
}
template <typename X, typename Y, typename ...Z, typename Dispatch>
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
@ -49392,6 +50070,13 @@ public:
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceMemoryProperties2, PhysicalDeviceMemoryBudgetPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMemoryPriorityFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMemoryPriorityFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryPriorityAllocateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBufferAddressFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBufferAddressFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<BufferCreateInfo, BufferDeviceAddressCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageStencilUsageCreateInfoEXT>{ enum { value = true }; };
@ -49413,6 +50098,7 @@ public:
template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; };
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceExternalImageFormatInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfo>{ enum { value = true }; };
@ -49447,6 +50133,8 @@ public:
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DescriptorSetLayoutCreateInfo, DescriptorSetLayoutBindingFlagsCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDriverPropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDepthStencilResolvePropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<SubpassDescription2KHR, SubpassDescriptionDepthStencilResolveKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, DeviceMemoryOverallocationCreateInfoAMD>{ enum { value = true }; };
@ -50943,6 +51631,8 @@ public:
case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
case StructureType::ePhysicalDeviceDriverPropertiesKHR: return "PhysicalDeviceDriverPropertiesKHR";
case StructureType::ePhysicalDeviceFloatControlsPropertiesKHR: return "PhysicalDeviceFloatControlsPropertiesKHR";
case StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR: return "PhysicalDeviceDepthStencilResolvePropertiesKHR";
case StructureType::eSubpassDescriptionDepthStencilResolveKHR: return "SubpassDescriptionDepthStencilResolveKHR";
case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
@ -50959,7 +51649,14 @@ public:
case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT: return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT: return "RenderPassFragmentDensityMapCreateInfoEXT";
case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT: return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT: return "PhysicalDeviceMemoryBudgetPropertiesEXT";
case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT: return "PhysicalDeviceMemoryPriorityFeaturesEXT";
case StructureType::eMemoryPriorityAllocateInfoEXT: return "MemoryPriorityAllocateInfoEXT";
case StructureType::ePhysicalDeviceBufferAddressFeaturesEXT: return "PhysicalDeviceBufferAddressFeaturesEXT";
case StructureType::eBufferDeviceAddressInfoEXT: return "BufferDeviceAddressInfoEXT";
case StructureType::eBufferDeviceAddressCreateInfoEXT: return "BufferDeviceAddressCreateInfoEXT";
case StructureType::eImageStencilUsageCreateInfoEXT: return "ImageStencilUsageCreateInfoEXT";
case StructureType::eValidationFeaturesEXT: return "ValidationFeaturesEXT";
default: return "invalid";
}
}
@ -51229,6 +51926,7 @@ public:
case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
case BufferUsageFlagBits::eRayTracingNV: return "RayTracingNV";
case BufferUsageFlagBits::eShaderDeviceAddressEXT: return "ShaderDeviceAddressEXT";
default: return "invalid";
}
}
@ -51250,6 +51948,7 @@ public:
if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) result += "TransformFeedbackCounterBufferEXT | ";
if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
if (value & BufferUsageFlagBits::eRayTracingNV) result += "RayTracingNV | ";
if (value & BufferUsageFlagBits::eShaderDeviceAddressEXT) result += "ShaderDeviceAddressEXT | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
@ -51261,6 +51960,7 @@ public:
case BufferCreateFlagBits::eSparseResidency: return "SparseResidency";
case BufferCreateFlagBits::eSparseAliased: return "SparseAliased";
case BufferCreateFlagBits::eProtected: return "Protected";
case BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT: return "DeviceAddressCaptureReplayEXT";
default: return "invalid";
}
}
@ -51273,6 +51973,7 @@ public:
if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
if (value & BufferCreateFlagBits::eProtected) result += "Protected | ";
if (value & BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT) result += "DeviceAddressCaptureReplayEXT | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
@ -52235,6 +52936,31 @@ public:
}
}
VULKAN_HPP_INLINE std::string to_string(ValidationFeatureEnableEXT value)
{
switch (value)
{
case ValidationFeatureEnableEXT::eGpuAssisted: return "GpuAssisted";
case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot: return "GpuAssistedReserveBindingSlot";
default: return "invalid";
}
}
VULKAN_HPP_INLINE std::string to_string(ValidationFeatureDisableEXT value)
{
switch (value)
{
case ValidationFeatureDisableEXT::eAll: return "All";
case ValidationFeatureDisableEXT::eShaders: return "Shaders";
case ValidationFeatureDisableEXT::eThreadSafety: return "ThreadSafety";
case ValidationFeatureDisableEXT::eApiParameters: return "ApiParameters";
case ValidationFeatureDisableEXT::eObjectLifetimes: return "ObjectLifetimes";
case ValidationFeatureDisableEXT::eCoreChecks: return "CoreChecks";
case ValidationFeatureDisableEXT::eUniqueHandles: return "UniqueHandles";
default: return "invalid";
}
}
VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlagBits value)
{
switch (value)
@ -52954,6 +53680,31 @@ public:
return "{" + result.substr(0, result.size() - 3) + "}";
}
VULKAN_HPP_INLINE std::string to_string(ResolveModeFlagBitsKHR value)
{
switch (value)
{
case ResolveModeFlagBitsKHR::eNone: return "None";
case ResolveModeFlagBitsKHR::eSampleZero: return "SampleZero";
case ResolveModeFlagBitsKHR::eAverage: return "Average";
case ResolveModeFlagBitsKHR::eMin: return "Min";
case ResolveModeFlagBitsKHR::eMax: return "Max";
default: return "invalid";
}
}
VULKAN_HPP_INLINE std::string to_string(ResolveModeFlagsKHR value)
{
if (!value) return "{}";
std::string result;
if (value & ResolveModeFlagBitsKHR::eNone) result += "None | ";
if (value & ResolveModeFlagBitsKHR::eSampleZero) result += "SampleZero | ";
if (value & ResolveModeFlagBitsKHR::eAverage) result += "Average | ";
if (value & ResolveModeFlagBitsKHR::eMin) result += "Min | ";
if (value & ResolveModeFlagBitsKHR::eMax) result += "Max | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value)
{
switch (value)
@ -53344,6 +54095,7 @@ public:
#ifdef VK_USE_PLATFORM_ANDROID_KHR
PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
@ -53744,6 +54496,7 @@ public:
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID"));
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(device ? device.getProcAddr( "vkGetBufferDeviceAddressEXT") : instance.getProcAddr( "vkGetBufferDeviceAddressEXT"));
vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(device ? device.getProcAddr( "vkGetBufferMemoryRequirements") : instance.getProcAddr( "vkGetBufferMemoryRequirements"));
vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2") : instance.getProcAddr( "vkGetBufferMemoryRequirements2"));
vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2KHR") : instance.getProcAddr( "vkGetBufferMemoryRequirements2KHR"));

2
include/vulkan/vulkan_android.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

155
include/vulkan/vulkan_core.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
@ -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 96
#define VK_HEADER_VERSION 97
#define VK_NULL_HANDLE 0
@ -148,6 +148,7 @@ typedef enum VkResult {
VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
VK_ERROR_FRAGMENTATION_EXT = -1000161000,
VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
@ -444,6 +445,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000,
VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
@ -460,7 +463,14 @@ typedef enum VkStructureType {
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_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = 1000244000,
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
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,
@ -1539,6 +1549,7 @@ typedef enum VkBufferCreateFlagBits {
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
@ -1557,6 +1568,7 @@ typedef enum VkBufferUsageFlagBits {
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
@ -6192,6 +6204,40 @@ typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR {
#define VK_KHR_depth_stencil_resolve 1
#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
typedef enum VkResolveModeFlagBitsKHR {
VK_RESOLVE_MODE_NONE_KHR = 0,
VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = 0x00000001,
VK_RESOLVE_MODE_AVERAGE_BIT_KHR = 0x00000002,
VK_RESOLVE_MODE_MIN_BIT_KHR = 0x00000004,
VK_RESOLVE_MODE_MAX_BIT_KHR = 0x00000008,
VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkResolveModeFlagBitsKHR;
typedef VkFlags VkResolveModeFlagsKHR;
typedef struct VkSubpassDescriptionDepthStencilResolveKHR {
VkStructureType sType;
const void* pNext;
VkResolveModeFlagBitsKHR depthResolveMode;
VkResolveModeFlagBitsKHR stencilResolveMode;
const VkAttachmentReference2KHR* pDepthStencilResolveAttachment;
} VkSubpassDescriptionDepthStencilResolveKHR;
typedef struct VkPhysicalDeviceDepthStencilResolvePropertiesKHR {
VkStructureType sType;
void* pNext;
VkResolveModeFlagsKHR supportedDepthResolveModes;
VkResolveModeFlagsKHR supportedStencilResolveModes;
VkBool32 independentResolveNone;
VkBool32 independentResolve;
} VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
#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"
@ -8926,6 +8972,72 @@ typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
#define VK_EXT_memory_budget 1
#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
VkStructureType sType;
void* pNext;
VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
} VkPhysicalDeviceMemoryBudgetPropertiesEXT;
#define VK_EXT_memory_priority 1
#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 memoryPriority;
} VkPhysicalDeviceMemoryPriorityFeaturesEXT;
typedef struct VkMemoryPriorityAllocateInfoEXT {
VkStructureType sType;
const void* pNext;
float priority;
} VkMemoryPriorityAllocateInfoEXT;
#define VK_EXT_buffer_device_address 1
typedef uint64_t VkDeviceAddress;
#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
typedef struct VkPhysicalDeviceBufferAddressFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 bufferDeviceAddress;
VkBool32 bufferDeviceAddressCaptureReplay;
VkBool32 bufferDeviceAddressMultiDevice;
} VkPhysicalDeviceBufferAddressFeaturesEXT;
typedef struct VkBufferDeviceAddressInfoEXT {
VkStructureType sType;
const void* pNext;
VkBuffer buffer;
} VkBufferDeviceAddressInfoEXT;
typedef struct VkBufferDeviceAddressCreateInfoEXT {
VkStructureType sType;
const void* pNext;
VkDeviceSize deviceAddress;
} VkBufferDeviceAddressCreateInfoEXT;
typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
VkDevice device,
const VkBufferDeviceAddressInfoEXT* pInfo);
#endif
#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"
@ -8938,6 +9050,45 @@ typedef struct VkImageStencilUsageCreateInfoEXT {
#define VK_EXT_validation_features 1
#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 1
#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
typedef enum VkValidationFeatureEnableEXT {
VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationFeatureEnableEXT;
typedef enum VkValidationFeatureDisableEXT {
VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
VK_VALIDATION_FEATURE_DISABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,
VK_VALIDATION_FEATURE_DISABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT,
VK_VALIDATION_FEATURE_DISABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT + 1),
VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationFeatureDisableEXT;
typedef struct VkValidationFeaturesEXT {
VkStructureType sType;
const void* pNext;
uint32_t enabledValidationFeatureCount;
const VkValidationFeatureEnableEXT* pEnabledValidationFeatures;
uint32_t disabledValidationFeatureCount;
const VkValidationFeatureDisableEXT* pDisabledValidationFeatures;
} VkValidationFeaturesEXT;
#ifdef __cplusplus
}
#endif

2
include/vulkan/vulkan_fuchsia.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_ios.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_macos.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_vi.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_wayland.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_win32.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_xcb.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_xlib.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
include/vulkan/vulkan_xlib_xrandr.h
View file

@ -6,7 +6,7 @@ extern "C" {
#endif
/*
** Copyright (c) 2015-2018 The Khronos Group Inc.
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.

2
registry/cgenerator.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright (c) 2013-2018 The Khronos Group Inc.
# Copyright (c) 2013-2019 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.

2
registry/generator.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright (c) 2013-2018 The Khronos Group Inc.
# Copyright (c) 2013-2019 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.

4
registry/genvk.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3
#
# Copyright (c) 2013-2018 The Khronos Group Inc.
# Copyright (c) 2013-2019 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@ -90,7 +90,7 @@ def makeGenOpts(args):
# Copyright text prefixing all headers (list of strings).
prefixStrings = [
'/*',
'** Copyright (c) 2015-2018 The Khronos Group Inc.',
'** Copyright (c) 2015-2019 The Khronos Group Inc.',
'**',
'** Licensed under the Apache License, Version 2.0 (the "License");',
'** you may not use this file except in compliance with the License.',

2
registry/reg.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright (c) 2013-2018 The Khronos Group Inc.
# Copyright (c) 2013-2019 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.

228
registry/validusage.json
View file

@ -1,9 +1,9 @@
{
"version info": {
"schema version": 2,
"api version": "1.1.96",
"comment": "from git branch: master commit: b557dd2167a5b2c92a03a69b34ff7a4431cca7ad",
"date": "2018-12-17 16:39:53Z"
"api version": "1.1.97",
"comment": "from git branch: master commit: a8c96cb464e849ffd88b5518cebcb4e1beb83e01",
"date": "2019-01-07 16:51:11Z"
},
"validation": {
"vkGetInstanceProcAddr": {
@ -66,7 +66,7 @@
},
{
"vuid": "VUID-VkInstanceCreateInfo-pNext-pNext",
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDebugReportCallbackCreateInfoEXT\">VkDebugReportCallbackCreateInfoEXT</a>, <a href=\"#VkDebugUtilsMessengerCreateInfoEXT\">VkDebugUtilsMessengerCreateInfoEXT</a>, or <a href=\"#VkValidationFlagsEXT\">VkValidationFlagsEXT</a>"
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDebugReportCallbackCreateInfoEXT\">VkDebugReportCallbackCreateInfoEXT</a>, <a href=\"#VkDebugUtilsMessengerCreateInfoEXT\">VkDebugUtilsMessengerCreateInfoEXT</a>, <a href=\"#VkValidationFeaturesEXT\">VkValidationFeaturesEXT</a>, or <a href=\"#VkValidationFlagsEXT\">VkValidationFlagsEXT</a>"
},
{
"vuid": "VUID-VkInstanceCreateInfo-sType-unique",
@ -106,6 +106,22 @@
}
]
},
"VkValidationFeaturesEXT": {
"(VK_EXT_validation_features)": [
{
"vuid": "VUID-VkValidationFeaturesEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT</code>"
},
{
"vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-parameter",
"text": " If <code>enabledValidationFeatureCount</code> is not <code>0</code>, <code>pEnabledValidationFeatures</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>enabledValidationFeatureCount</code> valid <a href=\"#VkValidationFeatureEnableEXT\">VkValidationFeatureEnableEXT</a> values"
},
{
"vuid": "VUID-VkValidationFeaturesEXT-pDisabledValidationFeatures-parameter",
"text": " If <code>disabledValidationFeatureCount</code> is not <code>0</code>, <code>pDisabledValidationFeatures</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>disabledValidationFeatureCount</code> valid <a href=\"#VkValidationFeatureDisableEXT\">VkValidationFeatureDisableEXT</a> values"
}
]
},
"VkApplicationInfo": {
"core": [
{
@ -198,7 +214,7 @@
},
{
"vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext",
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceConservativeRasterizationPropertiesEXT\">VkPhysicalDeviceConservativeRasterizationPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>, <a href=\"#VkPhysicalDeviceMeshShaderPropertiesNV\">VkPhysicalDeviceMeshShaderPropertiesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\">VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX</a>, <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>, <a href=\"#VkPhysicalDevicePCIBusInfoPropertiesEXT\">VkPhysicalDevicePCIBusInfoPropertiesEXT</a>, <a href=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
},
{
"vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@ -346,7 +362,7 @@
},
{
"vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFloat16Int8FeaturesKHR\">VkPhysicalDeviceFloat16Int8FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeaturesEXT\">VkPhysicalDeviceScalarBlockLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDrawParameterFeatures\">VkPhysicalDeviceShaderDrawParameterFeatures</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVariablePointerFeatures\">VkPhysicalDeviceVariablePointerFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</a>"
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferAddressFeaturesEXT\">VkPhysicalDeviceBufferAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFloat16Int8FeaturesKHR\">VkPhysicalDeviceFloat16Int8FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeaturesEXT\">VkPhysicalDeviceScalarBlockLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDrawParameterFeatures\">VkPhysicalDeviceShaderDrawParameterFeatures</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVariablePointerFeatures\">VkPhysicalDeviceVariablePointerFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</a>"
},
{
"vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@ -2568,11 +2584,11 @@
},
{
"vuid": "VUID-vkCmdPipelineBarrier-image-01179",
"text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the <code>image</code> member of any element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal to one of the elements of <code>pAttachments</code> that the current <code>framebuffer</code> was created with, that is also referred to by one of the elements of the <code>pColorAttachments</code>, <code>pResolveAttachments</code> or <code>pDepthStencilAttachment</code> members of the <code>VkSubpassDescription</code> instance that the current subpass was created with"
"text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the <code>image</code> member of any element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal to one of the elements of <code>pAttachments</code> that the current <code>framebuffer</code> was created with, that is also referred to by one of the elements of the <code>pColorAttachments</code>, <code>pResolveAttachments</code> or <code>pDepthStencilAttachment</code> members of the <code>VkSubpassDescription</code> instance"
},
{
"vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01180",
"text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the <code>oldLayout</code> and <code>newLayout</code> members of any element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal to the <code>layout</code> member of an element of the <code>pColorAttachments</code>, <code>pResolveAttachments</code> or <code>pDepthStencilAttachment</code> members of the <code>VkSubpassDescription</code> instance that the current subpass was created with, that refers to the same <code>image</code>"
"text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the <code>oldLayout</code> and <code>newLayout</code> members of any element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal to the <code>layout</code> member of an element of the <code>pColorAttachments</code>, <code>pResolveAttachments</code> or <code>pDepthStencilAttachment</code> members of the <code>VkSubpassDescription</code> instance"
},
{
"vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01181",
@ -3744,6 +3760,66 @@
}
]
},
"VkSubpassDescriptionDepthStencilResolveKHR": {
"(VK_KHR_create_renderpass2)+(VK_KHR_depth_stencil_resolve)": [
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03177",
"text": " If <code>pDepthStencilResolveAttachment</code> is not <code>NULL</code> and does not have the value <code>VK_ATTACHMENT_UNUSED</code>, <code>pDepthStencilAttachment</code> <strong class=\"purple\">must</strong> not have the value <code>VK_ATTACHMENT_UNUSED</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03178",
"text": " If <code>pDepthStencilResolveAttachment</code> is not <code>NULL</code> and does not have the value <code>VK_ATTACHMENT_UNUSED</code>, <code>depthResolveMode</code> and <code>stencilResolveMode</code> <strong class=\"purple\">must</strong> not both be <code>VK_RESOLVE_MODE_NONE_KHR</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03179",
"text": " If <code>pDepthStencilResolveAttachment</code> is not <code>NULL</code>, the sample count of <code>pDepthStencilAttachment</code> <strong class=\"purple\">must</strong> be anything other than <code>VK_SAMPLE_COUNT_1_BIT</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03180",
"text": " <code>pDepthStencilResolveAttachment</code> <strong class=\"purple\">must</strong> have a sample count of <code>VK_SAMPLE_COUNT_1_BIT</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03181",
"text": " If the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilResolveAttachment</code> has a depth component, then the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilAttachment</code> <strong class=\"purple\">must</strong> have a depth component with the same number of bits and numerical type"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03182",
"text": " If the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilResolveAttachment</code> has a stencil component, then the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilAttachment</code> <strong class=\"purple\">must</strong> have a stencil component with the same number of bits and numerical type"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-depthResolveMode-03183",
"text": " The value of <code>depthResolveMode</code> <strong class=\"purple\">must</strong> be one of the bits set in <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>supportedDepthResolveModes</code> or <code>VK_RESOLVE_MODE_NONE_KHR</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-stencilResolveMode-03184",
"text": " The value of <code>stencilResolveMode</code> <strong class=\"purple\">must</strong> be one of the bits set in <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>supportedStencilResolveModes</code> or <code>VK_RESOLVE_MODE_NONE_KHR</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03185",
"text": " If the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilResolveAttachment</code> has both depth and stencil components, <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>independentResolve</code> is <code>VK_FALSE</code>, and <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>independentResolveNone</code> is <code>VK_FALSE</code>, then the values of <code>depthResolveMode</code> and <code>stencilResolveMode</code> <strong class=\"purple\">must</strong> be identical"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-03186",
"text": " If the <a href=\"#VkFormat\">VkFormat</a> of <code>pDepthStencilResolveAttachment</code> has both depth and stencil components, <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>independentResolve</code> is <code>VK_FALSE</code> and <a href=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>::<code>independentResolveNone</code> is <code>VK_TRUE</code>, then the values of <code>depthResolveMode</code> and <code>stencilResolveMode</code> <strong class=\"purple\">must</strong> be identical or one of them <strong class=\"purple\">must</strong> be <code>VK_RESOLVE_MODE_NONE_KHR</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR</code>"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-depthResolveMode-parameter",
"text": " <code>depthResolveMode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkResolveModeFlagBitsKHR\">VkResolveModeFlagBitsKHR</a> value"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-stencilResolveMode-parameter",
"text": " <code>stencilResolveMode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkResolveModeFlagBitsKHR\">VkResolveModeFlagBitsKHR</a> value"
},
{
"vuid": "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-parameter",
"text": " If <code>pDepthStencilResolveAttachment</code> is not <code>NULL</code>, <code>pDepthStencilResolveAttachment</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAttachmentReference2KHR</code> structure"
}
]
},
"VkAttachmentReference2KHR": {
"(VK_KHR_create_renderpass2)": [
{
@ -3949,8 +4025,8 @@
"text": " Each element of <code>pAttachments</code> that is used as a color attachment or resolve attachment by <code>renderPass</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00878",
"text": " Each element of <code>pAttachments</code> that is used as a depth/stencil attachment by <code>renderPass</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
"vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02603",
"text": " Each element of <code>pAttachments</code> that is used as a depth/stencil"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00879",
@ -5980,7 +6056,15 @@
},
{
"vuid": "VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext",
"text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
"text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceMemoryBudgetPropertiesEXT\">VkPhysicalDeviceMemoryBudgetPropertiesEXT</a>"
}
]
},
"VkPhysicalDeviceMemoryBudgetPropertiesEXT": {
"(VK_EXT_memory_budget)": [
{
"vuid": "VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT</code>"
}
]
},
@ -6140,7 +6224,7 @@
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-pNext",
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDedicatedAllocationMemoryAllocateInfoNV\">VkDedicatedAllocationMemoryAllocateInfoNV</a>, <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>, <a href=\"#VkExportMemoryAllocateInfoNV\">VkExportMemoryAllocateInfoNV</a>, <a href=\"#VkExportMemoryWin32HandleInfoKHR\">VkExportMemoryWin32HandleInfoKHR</a>, <a href=\"#VkExportMemoryWin32HandleInfoNV\">VkExportMemoryWin32HandleInfoNV</a>, <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a>, <a href=\"#VkImportMemoryFdInfoKHR\">VkImportMemoryFdInfoKHR</a>, <a href=\"#VkImportMemoryHostPointerInfoEXT\">VkImportMemoryHostPointerInfoEXT</a>, <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a>, <a href=\"#VkImportMemoryWin32HandleInfoNV\">VkImportMemoryWin32HandleInfoNV</a>, <a href=\"#VkMemoryAllocateFlagsInfo\">VkMemoryAllocateFlagsInfo</a>, or <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>"
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDedicatedAllocationMemoryAllocateInfoNV\">VkDedicatedAllocationMemoryAllocateInfoNV</a>, <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>, <a href=\"#VkExportMemoryAllocateInfoNV\">VkExportMemoryAllocateInfoNV</a>, <a href=\"#VkExportMemoryWin32HandleInfoKHR\">VkExportMemoryWin32HandleInfoKHR</a>, <a href=\"#VkExportMemoryWin32HandleInfoNV\">VkExportMemoryWin32HandleInfoNV</a>, <a href=\"#VkImportAndroidHardwareBufferInfoANDROID\">VkImportAndroidHardwareBufferInfoANDROID</a>, <a href=\"#VkImportMemoryFdInfoKHR\">VkImportMemoryFdInfoKHR</a>, <a href=\"#VkImportMemoryHostPointerInfoEXT\">VkImportMemoryHostPointerInfoEXT</a>, <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a>, <a href=\"#VkImportMemoryWin32HandleInfoNV\">VkImportMemoryWin32HandleInfoNV</a>, <a href=\"#VkMemoryAllocateFlagsInfo\">VkMemoryAllocateFlagsInfo</a>, <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>, or <a href=\"#VkMemoryPriorityAllocateInfoEXT\">VkMemoryPriorityAllocateInfoEXT</a>"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-sType-unique",
@ -6264,6 +6348,18 @@
}
]
},
"VkMemoryPriorityAllocateInfoEXT": {
"(VK_EXT_memory_priority)": [
{
"vuid": "VUID-VkMemoryPriorityAllocateInfoEXT-priority-02602",
"text": " <code>priority</code> <strong class=\"purple\">must</strong> be between <code>0</code> and <code>1</code>, inclusive"
},
{
"vuid": "VUID-VkMemoryPriorityAllocateInfoEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT</code>"
}
]
},
"VkExportMemoryAllocateInfo": {
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
{
@ -7094,7 +7190,7 @@
},
{
"vuid": "VUID-VkBufferCreateInfo-pNext-pNext",
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDedicatedAllocationBufferCreateInfoNV\">VkDedicatedAllocationBufferCreateInfoNV</a> or <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>"
"text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkBufferDeviceAddressCreateInfoEXT\">VkBufferDeviceAddressCreateInfoEXT</a>, <a href=\"#VkDedicatedAllocationBufferCreateInfoNV\">VkDedicatedAllocationBufferCreateInfoNV</a>, or <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>"
},
{
"vuid": "VUID-VkBufferCreateInfo-sType-unique",
@ -7150,6 +7246,20 @@
"vuid": "VUID-VkBufferCreateInfo-pNext-01571",
"text": " If the <code>pNext</code> chain contains an instance of <a href=\"#VkDedicatedAllocationBufferCreateInfoNV\">VkDedicatedAllocationBufferCreateInfoNV</a>, and the <code>dedicatedAllocation</code> member of the chained structure is <code>VK_TRUE</code>, then <code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_BUFFER_CREATE_SPARSE_BINDING_BIT</code>, <code>VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT</code>, or <code>VK_BUFFER_CREATE_SPARSE_ALIASED_BIT</code>"
}
],
"(VK_EXT_buffer_device_address)": [
{
"vuid": "VUID-VkBufferCreateInfo-deviceAddress-02604",
"text": " If <a href=\"#VkBufferDeviceAddressCreateInfoEXT\">VkBufferDeviceAddressCreateInfoEXT</a>::<code>deviceAddress</code> is not zero, <code>flags</code> <strong class=\"purple\">must</strong> include <code>VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT</code>"
},
{
"vuid": "VUID-VkBufferCreateInfo-flags-02605",
"text": " If <code>flags</code> includes <code>VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT</code>, the <a href=\"#features-features-bufferDeviceAddressCaptureReplay\">bufferDeviceAddressCaptureReplay</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-VkBufferCreateInfo-usage-02606",
"text": " If <code>usage</code> includes <code>VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT</code>, the <a href=\"#features-features-bufferDeviceAddress\">bufferDeviceAddress</a> feature <strong class=\"purple\">must</strong> be enabled"
}
]
},
"VkDedicatedAllocationBufferCreateInfoNV": {
@ -7172,6 +7282,14 @@
}
]
},
"VkBufferDeviceAddressCreateInfoEXT": {
"(VK_EXT_buffer_device_address)": [
{
"vuid": "VUID-VkBufferDeviceAddressCreateInfoEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT</code>"
}
]
},
"vkDestroyBuffer": {
"core": [
{
@ -11532,6 +11650,50 @@
}
]
},
"vkGetBufferDeviceAddressEXT": {
"(VK_EXT_buffer_device_address)": [
{
"vuid": "VUID-vkGetBufferDeviceAddressEXT-None-02598",
"text": " The <a href=\"#features-features-bufferDeviceAddress\">bufferDeviceAddress</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetBufferDeviceAddressEXT-device-02599",
"text": " If <code>device</code> was created with multiple physical devices, then the <a href=\"#features-features-bufferDeviceAddressMultiDevice\">bufferDeviceAddressMultiDevice</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetBufferDeviceAddressEXT-device-parameter",
"text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
},
{
"vuid": "VUID-vkGetBufferDeviceAddressEXT-pInfo-parameter",
"text": " <code>pInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkBufferDeviceAddressInfoEXT</code> structure"
}
]
},
"VkBufferDeviceAddressInfoEXT": {
"(VK_EXT_buffer_device_address)": [
{
"vuid": "VUID-VkBufferDeviceAddressInfoEXT-buffer-02600",
"text": " If <code>buffer</code> is non-sparse and was not created with the <code>VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT</code> flag, then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
},
{
"vuid": "VUID-VkBufferDeviceAddressInfoEXT-buffer-02601",
"text": " <code>buffer</code> <strong class=\"purple\">must</strong> have been created with <code>VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT</code>"
},
{
"vuid": "VUID-VkBufferDeviceAddressInfoEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT</code>"
},
{
"vuid": "VUID-VkBufferDeviceAddressInfoEXT-pNext-pNext",
"text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
},
{
"vuid": "VUID-VkBufferDeviceAddressInfoEXT-buffer-parameter",
"text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
}
]
},
"vkCreateQueryPool": {
"core": [
{
@ -16604,10 +16766,6 @@
"vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV</code>"
},
{
"vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-pViewportWScalings-parameter",
"text": " <code>pViewportWScalings</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>viewportCount</code> <code>VkViewportWScalingNV</code> structures"
},
{
"vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength",
"text": " <code>viewportCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
@ -21270,6 +21428,18 @@
}
]
},
"VkHdrMetadataEXT": {
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)": [
{
"vuid": "VUID-VkHdrMetadataEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_HDR_METADATA_EXT</code>"
},
{
"vuid": "VUID-VkHdrMetadataEXT-pNext-pNext",
"text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
}
]
},
"vkCmdTraceRaysNV": {
"(VK_NV_ray_tracing)": [
{
@ -21924,6 +22094,22 @@
}
]
},
"VkPhysicalDeviceMemoryPriorityFeaturesEXT": {
"(VK_EXT_memory_priority)": [
{
"vuid": "VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT</code>"
}
]
},
"VkPhysicalDeviceBufferAddressFeaturesEXT": {
"(VK_EXT_buffer_device_address)": [
{
"vuid": "VUID-VkPhysicalDeviceBufferAddressFeaturesEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT</code>"
}
]
},
"VkPhysicalDevicePushDescriptorPropertiesKHR": {
"(VK_KHR_push_descriptor)": [
{
@ -22084,6 +22270,14 @@
}
]
},
"VkPhysicalDeviceDepthStencilResolvePropertiesKHR": {
"(VK_KHR_depth_stencil_resolve)": [
{
"vuid": "VUID-VkPhysicalDeviceDepthStencilResolvePropertiesKHR-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR</code>"
}
]
},
"VkPhysicalDeviceShadingRateImagePropertiesNV": {
"(VK_NV_shading_rate_image)": [
{

175
registry/vk.xml
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<registry>
<comment>
Copyright (c) 2015-2018 The Khronos Group Inc.
Copyright (c) 2015-2019 The Khronos Group Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@ -146,7 +146,7 @@ server.
<type category="define">// Vulkan 1.1 version number
#define <name>VK_API_VERSION_1_1</name> <type>VK_MAKE_VERSION</type>(1, 1, 0)// Patch version should always be set to 0</type>
<type category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 96</type>
#define <name>VK_HEADER_VERSION</name> 97</type>
<type category="define">
#define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@ -170,6 +170,7 @@ server.
<type category="basetype">typedef <type>uint32_t</type> <name>VkBool32</name>;</type>
<type category="basetype">typedef <type>uint32_t</type> <name>VkFlags</name>;</type>
<type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceSize</name>;</type>
<type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceAddress</name>;</type>
<comment>Basic C types, pulled in via vk_platform.h</comment>
<type requires="vk_platform" name="void"/>
@ -308,6 +309,7 @@ server.
<type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationConservativeStateCreateFlagsEXT</name>;</type>
<type requires="VkDescriptorBindingFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorBindingFlagsEXT</name>;</type>
<type requires="VkConditionalRenderingFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkConditionalRenderingFlagsEXT</name>;</type>
<type requires="VkResolveModeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkResolveModeFlagsKHR</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationStateStreamCreateFlagsEXT</name>;</type>
@ -464,6 +466,7 @@ server.
<type name="VkQueueGlobalPriorityEXT" category="enum"/>
<type name="VkTimeDomainEXT" category="enum"/>
<type name="VkConservativeRasterizationModeEXT" category="enum"/>
<type name="VkResolveModeFlagBitsKHR" category="enum"/>
<type name="VkGeometryFlagBitsNV" category="enum"/>
<type name="VkGeometryInstanceFlagBitsNV" category="enum"/>
<type name="VkBuildAccelerationStructureFlagBitsNV" category="enum"/>
@ -486,6 +489,8 @@ server.
<type name="VkExternalMemoryHandleTypeFlagBitsNV" category="enum"/>
<type name="VkExternalMemoryFeatureFlagBitsNV" category="enum"/>
<type name="VkValidationCheckEXT" category="enum"/>
<type name="VkValidationFeatureEnableEXT" category="enum"/>
<type name="VkValidationFeatureDisableEXT" category="enum"/>
<type name="VkExternalMemoryHandleTypeFlagBits" category="enum"/>
<type category="enum" name="VkExternalMemoryHandleTypeFlagBitsKHR" alias="VkExternalMemoryHandleTypeFlagBits"/>
<type name="VkExternalMemoryFeatureFlagBits" category="enum"/>
@ -1728,6 +1733,14 @@ server.
<member><type>uint32_t</type> <name>disabledValidationCheckCount</name><comment>Number of validation checks to disable</comment></member>
<member len="disabledValidationCheckCount">const <type>VkValidationCheckEXT</type>* <name>pDisabledValidationChecks</name><comment>Validation checks to disable</comment></member>
</type>
<type category="struct" name="VkValidationFeaturesEXT" structextends="VkInstanceCreateInfo">
<member values="VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name><comment>Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT</comment></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>uint32_t</type> <name>enabledValidationFeatureCount</name><comment>Number of validation features to enable</comment></member>
<member len="enabledValidationFeatureCount">const <type>VkValidationFeatureEnableEXT</type>* <name>pEnabledValidationFeatures</name><comment>Validation features to enable</comment></member>
<member optional="true"><type>uint32_t</type> <name>disabledValidationFeatureCount</name><comment>Number of validation features to disable</comment></member>
<member len="disabledValidationFeatureCount">const <type>VkValidationFeatureDisableEXT</type>* <name>pDisabledValidationFeatures</name><comment>Validation features to disable</comment></member>
</type>
<type category="struct" name="VkPipelineRasterizationStateRasterizationOrderAMD" structextends="VkPipelineRasterizationStateCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
@ -2462,15 +2475,15 @@ server.
<member values="VK_STRUCTURE_TYPE_HDR_METADATA_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<comment> From SMPTE 2086</comment>
<member><type>VkXYColorEXT</type> <name>displayPrimaryRed</name><comment>Display primary's Red</comment></member>
<member><type>VkXYColorEXT</type> <name>displayPrimaryGreen</name><comment>Display primary's Green</comment></member>
<member><type>VkXYColorEXT</type> <name>displayPrimaryBlue</name><comment>Display primary's Blue</comment></member>
<member><type>VkXYColorEXT</type> <name>whitePoint</name><comment>Display primary's Blue</comment></member>
<member><type>float</type> <name>maxLuminance</name><comment>Display maximum luminance</comment></member>
<member><type>float</type> <name>minLuminance</name><comment>Display minimum luminance</comment></member>
<member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryRed</name><comment>Display primary's Red</comment></member>
<member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryGreen</name><comment>Display primary's Green</comment></member>
<member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryBlue</name><comment>Display primary's Blue</comment></member>
<member noautovalidity="true"><type>VkXYColorEXT</type> <name>whitePoint</name><comment>Display primary's Blue</comment></member>
<member noautovalidity="true"><type>float</type> <name>maxLuminance</name><comment>Display maximum luminance</comment></member>
<member noautovalidity="true"><type>float</type> <name>minLuminance</name><comment>Display minimum luminance</comment></member>
<comment> From CTA 861.3</comment>
<member><type>float</type> <name>maxContentLightLevel</name><comment>Content maximum luminance</comment></member>
<member><type>float</type> <name>maxFrameAverageLightLevel</name></member>
<member noautovalidity="true"><type>float</type> <name>maxContentLightLevel</name><comment>Content maximum luminance</comment></member>
<member noautovalidity="true"><type>float</type> <name>maxFrameAverageLightLevel</name></member>
</type>
<type category="struct" name="VkRefreshCycleDurationGOOGLE" returnedonly="true">
<member><type>uint64_t</type> <name>refreshDuration</name><comment>Number of nanoseconds from the start of one refresh cycle to the next</comment></member>
@ -2513,7 +2526,7 @@ server.
<member>const <type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>viewportWScalingEnable</name></member>
<member><type>uint32_t</type> <name>viewportCount</name></member>
<member len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member>
<member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member>
</type>
<type category="struct" name="VkViewportSwizzleNV">
<member><type>VkViewportCoordinateSwizzleNV</type> <name>x</name></member>
@ -3325,6 +3338,21 @@ server.
<member><type>VkPipelineStageFlagBits</type> <name>stage</name></member>
<member noautovalidity="true"><type>void</type>* <name>pCheckpointMarker</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceDepthStencilResolvePropertiesKHR" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member><type>void</type>* <name>pNext</name></member>
<member><type>VkResolveModeFlagsKHR</type> <name>supportedDepthResolveModes</name><comment>supported depth resolve modes</comment></member>
<member><type>VkResolveModeFlagsKHR</type> <name>supportedStencilResolveModes</name><comment>supported stencil resolve modes</comment></member>
<member><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
<member><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
</type>
<type category="struct" name="VkSubpassDescriptionDepthStencilResolveKHR" structextends="VkSubpassDescription2KHR">
<member values="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member><type>VkResolveModeFlagBitsKHR</type> <name>depthResolveMode</name><comment>depth resolve mode</comment></member>
<member><type>VkResolveModeFlagBitsKHR</type> <name>stencilResolveMode</name><comment>stencil resolve mode</comment></member>
<member optional="true">const <type>VkAttachmentReference2KHR</type>* <name>pDepthStencilResolveAttachment</name><comment>depth/stencil resolve attachment</comment></member>
</type>
<type category="struct" name="VkImageViewASTCDecodeModeEXT" structextends="VkImageViewCreateInfo">
<member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
@ -3647,6 +3675,39 @@ server.
<member><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>scalarBlockLayout</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceMemoryBudgetPropertiesEXT" structextends="VkPhysicalDeviceMemoryProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceSize</type> <name>heapBudget</name>[<enum>VK_MAX_MEMORY_HEAPS</enum>]</member>
<member><type>VkDeviceSize</type> <name>heapUsage</name>[<enum>VK_MAX_MEMORY_HEAPS</enum>]</member>
</type>
<type category="struct" name="VkPhysicalDeviceMemoryPriorityFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>memoryPriority</name></member>
</type>
<type category="struct" name="VkMemoryPriorityAllocateInfoEXT" structextends="VkMemoryAllocateInfo">
<member values="VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member><type>float</type> <name>priority</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceBufferAddressFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>bufferDeviceAddress</name></member>
<member><type>VkBool32</type> <name>bufferDeviceAddressCaptureReplay</name></member>
<member><type>VkBool32</type> <name>bufferDeviceAddressMultiDevice</name></member>
</type>
<type category="struct" name="VkBufferDeviceAddressInfoEXT">
<member values="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member><type>VkBuffer</type> <name>buffer</name></member>
</type>
<type category="struct" name="VkBufferDeviceAddressCreateInfoEXT" structextends="VkBufferCreateInfo">
<member values="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceSize</type> <name>deviceAddress</name></member>
</type>
</types>
<comment>Vulkan enumerant (token) definitions</comment>
@ -4535,6 +4596,21 @@ server.
<enum value="1" name="VK_VALIDATION_CHECK_SHADERS_EXT"/>
<comment>Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension</comment>
</enums>
<enums name="VkValidationFeatureEnableEXT" type="enum">
<enum value="0" name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"/>
<enum value="1" name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"/>
<comment>Placeholder for validation feature enable enums to be defined for VK_EXT_validation_features extension</comment>
</enums>
<enums name="VkValidationFeatureDisableEXT" type="enum">
<enum value="0" name="VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"/>
<enum value="1" name="VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"/>
<enum value="2" name="VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"/>
<enum value="3" name="VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"/>
<enum value="4" name="VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"/>
<enum value="5" name="VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"/>
<enum value="6" name="VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"/>
<comment>Placeholder for validation feature disable enums to be defined for VK_EXT_validation_features extension</comment>
</enums>
<enums name="VkSubgroupFeatureFlagBits" type="bitmask">
<enum bitpos="0" name="VK_SUBGROUP_FEATURE_BASIC_BIT" comment="Basic subgroup operations"/>
<enum bitpos="1" name="VK_SUBGROUP_FEATURE_VOTE_BIT" comment="Vote subgroup operations"/>
@ -4764,6 +4840,13 @@ server.
<enums name="VkConditionalRenderingFlagBitsEXT" type="bitmask">
<enum bitpos="0" name="VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"/>
</enums>
<enums name="VkResolveModeFlagBitsKHR" type="bitmask">
<enum value="0" name="VK_RESOLVE_MODE_NONE_KHR"/>
<enum bitpos="0" name="VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR"/>
<enum bitpos="1" name="VK_RESOLVE_MODE_AVERAGE_BIT_KHR"/>
<enum bitpos="2" name="VK_RESOLVE_MODE_MIN_BIT_KHR"/>
<enum bitpos="3" name="VK_RESOLVE_MODE_MAX_BIT_KHR"/>
</enums>
<enums name="VkShadingRatePaletteEntryNV" type="enum">
<enum value="0" name="VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV"/>
<enum value="1" name="VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV"/>
@ -5151,7 +5234,7 @@ server.
<param><type>VkDeviceSize</type> <name>stride</name></param>
<param optional="true"><type>VkQueryResultFlags</type> <name>flags</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_DEVICE_ADDRESS_EXT">
<proto><type>VkResult</type> <name>vkCreateBuffer</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkBufferCreateInfo</type>* <name>pCreateInfo</name></param>
@ -7011,6 +7094,11 @@ server.
<param><type>VkImage</type> <name>image</name></param>
<param><type>VkImageDrmFormatModifierPropertiesEXT</type>* <name>pProperties</name></param>
</command>
<command>
<proto><type>VkDeviceAddress</type> <name>vkGetBufferDeviceAddressEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkBufferDeviceAddressInfoEXT</type>* <name>pInfo</name></param>
</command>
</commands>
<feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@ -7847,7 +7935,8 @@ server.
<enum bitpos="27" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_RESERVED_27_BIT_KHR"/>
<enum bitpos="30" extends="VkAccessFlagBits" name="VK_ACCESS_RESERVED_30_BIT_KHR"/>
<enum bitpos="31" extends="VkAccessFlagBits" name="VK_ACCESS_RESERVED_31_BIT_KHR"/>
<enum bitpos="14" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_14_BIT_KHR"/>
<enum bitpos="15" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_15_BIT_KHR"/>
<enum bitpos="16" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_16_BIT_KHR"/>
<enum bitpos="13" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_13_BIT_KHR"/>
<enum bitpos="14" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_14_BIT_KHR"/>
<enum bitpos="15" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_15_BIT_KHR"/>
@ -7865,6 +7954,7 @@ server.
<enum bitpos="28" extends="VkAccessFlagBits" name="VK_ACCESS_RESERVED_28_BIT_KHR"/>
<enum bitpos="29" extends="VkAccessFlagBits" name="VK_ACCESS_RESERVED_29_BIT_KHR"/>
<enum bitpos="13" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_13_BIT_KHR"/>
<enum bitpos="14" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_14_BIT_KHR"/>
<enum bitpos="10" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_10_BIT_KHR"/>
<enum bitpos="11" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_11_BIT_KHR"/>
<enum bitpos="12" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_12_BIT_KHR"/>
@ -9888,10 +9978,15 @@ server.
<enum bitpos="8" extends="VkSubgroupFeatureFlagBits" name="VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"/>
</require>
</extension>
<extension name="VK_KHR_extension_200" number="200" author="KHR" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
<extension name="VK_KHR_depth_stencil_resolve" number="200" type="device" requires="VK_KHR_create_renderpass2" author="KHR" contact="Jan-Harald Fredriksen @janharald" supported="vulkan">
<require>
<enum value="0" name="VK_KHR_EXTENSION_200_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_200&quot;" name="VK_KHR_EXTENSION_200_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_depth_stencil_resolve&quot;" name="VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR"/>
<type name="VkSubpassDescriptionDepthStencilResolveKHR"/>
<type name="VkPhysicalDeviceDepthStencilResolvePropertiesKHR"/>
<type name="VkResolveModeFlagBitsKHR"/>
</require>
</extension>
<extension name="VK_KHR_swapchain_mutable_format" number="201" type="device" author="KHR" requires="VK_KHR_swapchain,VK_KHR_maintenance2,VK_KHR_image_format_list" contact="Daniel Rakos @drakos-arm" supported="vulkan">
@ -10173,16 +10268,22 @@ server.
<enum value="&quot;VK_KHR_extension_237&quot;" name="VK_KHR_EXTENSION_237_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_KHR_extension_238" number="238" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="disabled">
<extension name="VK_EXT_memory_budget" number="238" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<require>
<enum value="0" name="VK_KHR_EXTENSION_238_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_238&quot;" name="VK_KHR_EXTENSION_238_EXTENSION_NAME"/>
<enum value="1" name="VK_EXT_MEMORY_BUDGET_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_memory_budget&quot;" name="VK_EXT_MEMORY_BUDGET_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"/>
<type name="VkPhysicalDeviceMemoryBudgetPropertiesEXT"/>
</require>
</extension>
<extension name="VK_KHR_extension_239" number="239" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="disabled">
<extension name="VK_EXT_memory_priority" number="239" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<require>
<enum value="0" name="VK_KHR_EXTENSION_239_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_239&quot;" name="VK_KHR_EXTENSION_239_EXTENSION_NAME"/>
<enum value="1" name="VK_EXT_MEMORY_PRIORITY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_memory_priority&quot;" name="VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"/>
<type name="VkPhysicalDeviceMemoryPriorityFeaturesEXT"/>
<type name="VkMemoryPriorityAllocateInfoEXT"/>
</require>
</extension>
<extension name="VK_KHR_extension_240" number="240" author="KHR" contact="Sandeep Shinde @nvidia" supported="disabled">
@ -10215,10 +10316,20 @@ server.
<enum value="&quot;VK_MESA_extension_244&quot;" name="VK_MESA_EXTENSION_244_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_245" number="245" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
<extension name="VK_EXT_buffer_device_address" number="245" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<require>
<enum value="0" name="VK_NV_EXTENSION_245_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_245&quot;" name="VK_NV_EXTENSION_245_EXTENSION_NAME"/>
<enum value="2" name="VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_buffer_device_address&quot;" name="VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"/>
<enum bitpos="17" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT"/>
<enum bitpos="4" extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT"/>
<enum offset="0" dir="-" extends="VkResult" name="VK_ERROR_INVALID_DEVICE_ADDRESS_EXT"/>
<type name="VkPhysicalDeviceBufferAddressFeaturesEXT"/>
<type name="VkBufferDeviceAddressInfoEXT"/>
<type name="VkBufferDeviceAddressCreateInfoEXT"/>
<command name="vkGetBufferDeviceAddressEXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_246" number="246" author="EXT" contact="Tobias Hector @tobski" supported="disabled">
@ -10235,10 +10346,12 @@ server.
<type name="VkImageStencilUsageCreateInfoEXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_248" number="248" author="EXT" contact="Karl Schultz @karlschultz" supported="disabled">
<extension name="VK_EXT_validation_features" number="248" type="instance" author="LUNARG" contact="Karl Schultz @karl-lunarg" supported="vulkan">
<require>
<enum value="0" name="VK_EXT_EXTENSION_248_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_248&quot;" name="VK_EXT_EXTENSION_248_EXTENSION_NAME"/>
<enum value="1" name="VK_EXT_VALIDATION_FEATURES_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_validation_features&quot;" name="VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"/>
<type name="VkValidationFeaturesEXT"/>
</require>
</extension>
<extension name="VK_KHR_extension_249" number="249" author="KHR" contact="Keith Packard @keithp" supported="disabled">
@ -10247,5 +10360,11 @@ server.
<enum value="&quot;VK_KHR_extension_249&quot;" name="VK_KHR_EXTENSION_249_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_250" number="250" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
<require>
<enum value="0" name="VK_NV_EXTENSION_250_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_250&quot;" name="VK_NV_EXTENSION_250_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
</registry>