openharmony/third_party_vulkan-headers
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_vulkan-headers synced 2024-11-23 16:00:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update for Vulkan-Docs 1.1.114

Browse Source
This commit is contained in:
Jon Leech 2019-07-07 23:34:18 -07:00 committed by Jon Leech
parent 9e747a25a8
commit e3f96a9cca
4 changed files with 809 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

498
include/vulkan/vulkan.hpp
View File

@ -56,7 +56,7 @@
# define VULKAN_HPP_ASSERT assert
#endif
static_assert( VK_HEADER_VERSION == 113 , "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 114 , "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
@ -5147,6 +5147,10 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
ePhysicalDeviceImagelessFramebufferFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR,
eFramebufferAttachmentsCreateInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR,
eFramebufferAttachmentImageInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR,
eRenderPassAttachmentBeginInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR,
eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,
@ -5569,6 +5573,10 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT";
case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT";
case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
case StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR : return "PhysicalDeviceImagelessFramebufferFeaturesKHR";
case StructureType::eFramebufferAttachmentsCreateInfoKHR : return "FramebufferAttachmentsCreateInfoKHR";
case StructureType::eFramebufferAttachmentImageInfoKHR : return "FramebufferAttachmentImageInfoKHR";
case StructureType::eRenderPassAttachmentBeginInfoKHR : return "RenderPassAttachmentBeginInfoKHR";
case StructureType::eAttachmentDescription2KHR : return "AttachmentDescription2KHR";
case StructureType::eAttachmentReference2KHR : return "AttachmentReference2KHR";
case StructureType::eSubpassDescription2KHR : return "SubpassDescription2KHR";
@ -6723,10 +6731,8 @@ namespace VULKAN_HPP_NAMESPACE
if ( !value ) return "{}";
std::string result;
if ( value & CullModeFlagBits::eNone ) result += "None | ";
if ( value & CullModeFlagBits::eFront ) result += "Front | ";
if ( value & CullModeFlagBits::eBack ) result += "Back | ";
if ( value & CullModeFlagBits::eFrontAndBack ) result += "FrontAndBack | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@ -8022,18 +8028,46 @@ namespace VULKAN_HPP_NAMESPACE
}
enum class FramebufferCreateFlagBits
{};
VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits )
{
return "(void)";
eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR
};
VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits value )
{
switch ( value )
{
case FramebufferCreateFlagBits::eImagelessKHR : return "ImagelessKHR";
default: return "invalid";
}
}
using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags )
VULKAN_HPP_INLINE FramebufferCreateFlags operator|( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
{
return "{}";
return FramebufferCreateFlags( bit0 ) | bit1;
}
VULKAN_HPP_INLINE FramebufferCreateFlags operator~( FramebufferCreateFlagBits bits )
{
return ~( FramebufferCreateFlags( bits ) );
}
template <> struct FlagTraits<FramebufferCreateFlagBits>
{
enum
{
allFlags = VkFlags(FramebufferCreateFlagBits::eImagelessKHR)
};
};
VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value )
{
if ( !value ) return "{}";
std::string result;
if ( value & FramebufferCreateFlagBits::eImagelessKHR ) result += "ImagelessKHR | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
enum class GeometryFlagBitsNV
@ -9661,7 +9695,6 @@ namespace VULKAN_HPP_NAMESPACE
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 | ";
@ -9927,8 +9960,6 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & ShaderStageFlagBits::eGeometry ) result += "Geometry | ";
if ( value & ShaderStageFlagBits::eFragment ) result += "Fragment | ";
if ( value & ShaderStageFlagBits::eCompute ) result += "Compute | ";
if ( value & ShaderStageFlagBits::eAllGraphics ) result += "AllGraphics | ";
if ( value & ShaderStageFlagBits::eAll ) result += "All | ";
if ( value & ShaderStageFlagBits::eRaygenNV ) result += "RaygenNV | ";
if ( value & ShaderStageFlagBits::eAnyHitNV ) result += "AnyHitNV | ";
if ( value & ShaderStageFlagBits::eClosestHitNV ) result += "ClosestHitNV | ";
@ -10077,7 +10108,6 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & StencilFaceFlagBits::eFront ) result += "Front | ";
if ( value & StencilFaceFlagBits::eBack ) result += "Back | ";
if ( value & StencilFaceFlagBits::eVkStencilFrontAndBack ) result += "VkStencilFrontAndBack | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@ -11125,6 +11155,8 @@ namespace VULKAN_HPP_NAMESPACE
struct FormatProperties;
struct FormatProperties2;
using FormatProperties2KHR = FormatProperties2;
struct FramebufferAttachmentImageInfoKHR;
struct FramebufferAttachmentsCreateInfoKHR;
struct FramebufferCreateInfo;
struct FramebufferMixedSamplesCombinationNV;
struct GeometryAABBNV;
@ -11295,6 +11327,7 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceImageFormatInfo2;
using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
struct PhysicalDeviceImageViewImageFormatInfoEXT;
struct PhysicalDeviceImagelessFramebufferFeaturesKHR;
struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
struct PhysicalDeviceLimits;
@ -11412,6 +11445,7 @@ namespace VULKAN_HPP_NAMESPACE
struct Rect2D;
struct RectLayerKHR;
struct RefreshCycleDurationGOOGLE;
struct RenderPassAttachmentBeginInfoKHR;
struct RenderPassBeginInfo;
struct RenderPassCreateInfo;
struct RenderPassCreateInfo2KHR;
@ -11525,6 +11559,9 @@ namespace VULKAN_HPP_NAMESPACE
class SurfaceKHR
{
public:
using CType = VkSurfaceKHR;
public:
VULKAN_HPP_CONSTEXPR SurfaceKHR()
: m_surfaceKHR(VK_NULL_HANDLE)
@ -11589,6 +11626,9 @@ namespace VULKAN_HPP_NAMESPACE
class DebugReportCallbackEXT
{
public:
using CType = VkDebugReportCallbackEXT;
public:
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
: m_debugReportCallbackEXT(VK_NULL_HANDLE)
@ -11653,6 +11693,9 @@ namespace VULKAN_HPP_NAMESPACE
class DebugUtilsMessengerEXT
{
public:
using CType = VkDebugUtilsMessengerEXT;
public:
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
: m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
@ -11717,6 +11760,9 @@ namespace VULKAN_HPP_NAMESPACE
class DisplayKHR
{
public:
using CType = VkDisplayKHR;
public:
VULKAN_HPP_CONSTEXPR DisplayKHR()
: m_displayKHR(VK_NULL_HANDLE)
@ -11781,6 +11827,9 @@ namespace VULKAN_HPP_NAMESPACE
class SwapchainKHR
{
public:
using CType = VkSwapchainKHR;
public:
VULKAN_HPP_CONSTEXPR SwapchainKHR()
: m_swapchainKHR(VK_NULL_HANDLE)
@ -11845,6 +11894,9 @@ namespace VULKAN_HPP_NAMESPACE
class Semaphore
{
public:
using CType = VkSemaphore;
public:
VULKAN_HPP_CONSTEXPR Semaphore()
: m_semaphore(VK_NULL_HANDLE)
@ -11909,6 +11961,9 @@ namespace VULKAN_HPP_NAMESPACE
class Fence
{
public:
using CType = VkFence;
public:
VULKAN_HPP_CONSTEXPR Fence()
: m_fence(VK_NULL_HANDLE)
@ -11973,6 +12028,9 @@ namespace VULKAN_HPP_NAMESPACE
class PerformanceConfigurationINTEL
{
public:
using CType = VkPerformanceConfigurationINTEL;
public:
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()
: m_performanceConfigurationINTEL(VK_NULL_HANDLE)
@ -12037,6 +12095,9 @@ namespace VULKAN_HPP_NAMESPACE
class QueryPool
{
public:
using CType = VkQueryPool;
public:
VULKAN_HPP_CONSTEXPR QueryPool()
: m_queryPool(VK_NULL_HANDLE)
@ -12101,6 +12162,9 @@ namespace VULKAN_HPP_NAMESPACE
class Buffer
{
public:
using CType = VkBuffer;
public:
VULKAN_HPP_CONSTEXPR Buffer()
: m_buffer(VK_NULL_HANDLE)
@ -12165,6 +12229,9 @@ namespace VULKAN_HPP_NAMESPACE
class PipelineLayout
{
public:
using CType = VkPipelineLayout;
public:
VULKAN_HPP_CONSTEXPR PipelineLayout()
: m_pipelineLayout(VK_NULL_HANDLE)
@ -12229,6 +12296,9 @@ namespace VULKAN_HPP_NAMESPACE
class DescriptorSet
{
public:
using CType = VkDescriptorSet;
public:
VULKAN_HPP_CONSTEXPR DescriptorSet()
: m_descriptorSet(VK_NULL_HANDLE)
@ -12293,6 +12363,9 @@ namespace VULKAN_HPP_NAMESPACE
class Pipeline
{
public:
using CType = VkPipeline;
public:
VULKAN_HPP_CONSTEXPR Pipeline()
: m_pipeline(VK_NULL_HANDLE)
@ -12357,6 +12430,9 @@ namespace VULKAN_HPP_NAMESPACE
class ImageView
{
public:
using CType = VkImageView;
public:
VULKAN_HPP_CONSTEXPR ImageView()
: m_imageView(VK_NULL_HANDLE)
@ -12421,6 +12497,9 @@ namespace VULKAN_HPP_NAMESPACE
class Image
{
public:
using CType = VkImage;
public:
VULKAN_HPP_CONSTEXPR Image()
: m_image(VK_NULL_HANDLE)
@ -12485,6 +12564,9 @@ namespace VULKAN_HPP_NAMESPACE
class AccelerationStructureNV
{
public:
using CType = VkAccelerationStructureNV;
public:
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
: m_accelerationStructureNV(VK_NULL_HANDLE)
@ -12549,6 +12631,9 @@ namespace VULKAN_HPP_NAMESPACE
class DescriptorUpdateTemplate
{
public:
using CType = VkDescriptorUpdateTemplate;
public:
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
: m_descriptorUpdateTemplate(VK_NULL_HANDLE)
@ -12614,6 +12699,9 @@ namespace VULKAN_HPP_NAMESPACE
class Event
{
public:
using CType = VkEvent;
public:
VULKAN_HPP_CONSTEXPR Event()
: m_event(VK_NULL_HANDLE)
@ -12678,6 +12766,9 @@ namespace VULKAN_HPP_NAMESPACE
class CommandBuffer
{
public:
using CType = VkCommandBuffer;
public:
VULKAN_HPP_CONSTEXPR CommandBuffer()
: m_commandBuffer(VK_NULL_HANDLE)
@ -13217,6 +13308,9 @@ namespace VULKAN_HPP_NAMESPACE
class DeviceMemory
{
public:
using CType = VkDeviceMemory;
public:
VULKAN_HPP_CONSTEXPR DeviceMemory()
: m_deviceMemory(VK_NULL_HANDLE)
@ -13281,6 +13375,9 @@ namespace VULKAN_HPP_NAMESPACE
class BufferView
{
public:
using CType = VkBufferView;
public:
VULKAN_HPP_CONSTEXPR BufferView()
: m_bufferView(VK_NULL_HANDLE)
@ -13345,6 +13442,9 @@ namespace VULKAN_HPP_NAMESPACE
class CommandPool
{
public:
using CType = VkCommandPool;
public:
VULKAN_HPP_CONSTEXPR CommandPool()
: m_commandPool(VK_NULL_HANDLE)
@ -13409,6 +13509,9 @@ namespace VULKAN_HPP_NAMESPACE
class PipelineCache
{
public:
using CType = VkPipelineCache;
public:
VULKAN_HPP_CONSTEXPR PipelineCache()
: m_pipelineCache(VK_NULL_HANDLE)
@ -13473,6 +13576,9 @@ namespace VULKAN_HPP_NAMESPACE
class DescriptorPool
{
public:
using CType = VkDescriptorPool;
public:
VULKAN_HPP_CONSTEXPR DescriptorPool()
: m_descriptorPool(VK_NULL_HANDLE)
@ -13537,6 +13643,9 @@ namespace VULKAN_HPP_NAMESPACE
class DescriptorSetLayout
{
public:
using CType = VkDescriptorSetLayout;
public:
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
: m_descriptorSetLayout(VK_NULL_HANDLE)
@ -13601,6 +13710,9 @@ namespace VULKAN_HPP_NAMESPACE
class Framebuffer
{
public:
using CType = VkFramebuffer;
public:
VULKAN_HPP_CONSTEXPR Framebuffer()
: m_framebuffer(VK_NULL_HANDLE)
@ -13665,6 +13777,9 @@ namespace VULKAN_HPP_NAMESPACE
class IndirectCommandsLayoutNVX
{
public:
using CType = VkIndirectCommandsLayoutNVX;
public:
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
: m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
@ -13729,6 +13844,9 @@ namespace VULKAN_HPP_NAMESPACE
class ObjectTableNVX
{
public:
using CType = VkObjectTableNVX;
public:
VULKAN_HPP_CONSTEXPR ObjectTableNVX()
: m_objectTableNVX(VK_NULL_HANDLE)
@ -13793,6 +13911,9 @@ namespace VULKAN_HPP_NAMESPACE
class RenderPass
{
public:
using CType = VkRenderPass;
public:
VULKAN_HPP_CONSTEXPR RenderPass()
: m_renderPass(VK_NULL_HANDLE)
@ -13857,6 +13978,9 @@ namespace VULKAN_HPP_NAMESPACE
class Sampler
{
public:
using CType = VkSampler;
public:
VULKAN_HPP_CONSTEXPR Sampler()
: m_sampler(VK_NULL_HANDLE)
@ -13921,6 +14045,9 @@ namespace VULKAN_HPP_NAMESPACE
class SamplerYcbcrConversion
{
public:
using CType = VkSamplerYcbcrConversion;
public:
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
: m_samplerYcbcrConversion(VK_NULL_HANDLE)
@ -13986,6 +14113,9 @@ namespace VULKAN_HPP_NAMESPACE
class ShaderModule
{
public:
using CType = VkShaderModule;
public:
VULKAN_HPP_CONSTEXPR ShaderModule()
: m_shaderModule(VK_NULL_HANDLE)
@ -14050,6 +14180,9 @@ namespace VULKAN_HPP_NAMESPACE
class ValidationCacheEXT
{
public:
using CType = VkValidationCacheEXT;
public:
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
: m_validationCacheEXT(VK_NULL_HANDLE)
@ -14114,6 +14247,9 @@ namespace VULKAN_HPP_NAMESPACE
class Queue
{
public:
using CType = VkQueue;
public:
VULKAN_HPP_CONSTEXPR Queue()
: m_queue(VK_NULL_HANDLE)
@ -14301,6 +14437,9 @@ namespace VULKAN_HPP_NAMESPACE
class Device
{
public:
using CType = VkDevice;
public:
VULKAN_HPP_CONSTEXPR Device()
: m_device(VK_NULL_HANDLE)
@ -15936,6 +16075,9 @@ namespace VULKAN_HPP_NAMESPACE
class DisplayModeKHR
{
public:
using CType = VkDisplayModeKHR;
public:
VULKAN_HPP_CONSTEXPR DisplayModeKHR()
: m_displayModeKHR(VK_NULL_HANDLE)
@ -16005,6 +16147,9 @@ namespace VULKAN_HPP_NAMESPACE
class PhysicalDevice
{
public:
using CType = VkPhysicalDevice;
public:
VULKAN_HPP_CONSTEXPR PhysicalDevice()
: m_physicalDevice(VK_NULL_HANDLE)
@ -16604,6 +16749,9 @@ namespace VULKAN_HPP_NAMESPACE
class Instance
{
public:
using CType = VkInstance;
public:
VULKAN_HPP_CONSTEXPR Instance()
: m_instance(VK_NULL_HANDLE)
@ -29592,6 +29740,196 @@ namespace VULKAN_HPP_NAMESPACE
};
static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
struct FramebufferAttachmentImageInfoKHR
{
FramebufferAttachmentImageInfoKHR( ImageCreateFlags flags_ = ImageCreateFlags(),
ImageUsageFlags usage_ = ImageUsageFlags(),
uint32_t width_ = 0,
uint32_t height_ = 0,
uint32_t layerCount_ = 0,
uint32_t viewFormatCount_ = 0,
const Format* pViewFormats_ = nullptr )
: flags( flags_ )
, usage( usage_ )
, width( width_ )
, height( height_ )
, layerCount( layerCount_ )
, viewFormatCount( viewFormatCount_ )
, pViewFormats( pViewFormats_ )
{}
FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs )
{
*reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
}
FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs )
{
*reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
return *this;
}
FramebufferAttachmentImageInfoKHR & setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setFlags( ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setUsage( ImageUsageFlags usage_ )
{
usage = usage_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setWidth( uint32_t width_ )
{
width = width_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setHeight( uint32_t height_ )
{
height = height_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setLayerCount( uint32_t layerCount_ )
{
layerCount = layerCount_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setViewFormatCount( uint32_t viewFormatCount_ )
{
viewFormatCount = viewFormatCount_;
return *this;
}
FramebufferAttachmentImageInfoKHR & setPViewFormats( const Format* pViewFormats_ )
{
pViewFormats = pViewFormats_;
return *this;
}
operator VkFramebufferAttachmentImageInfoKHR const&() const
{
return *reinterpret_cast<const VkFramebufferAttachmentImageInfoKHR*>( this );
}
operator VkFramebufferAttachmentImageInfoKHR &()
{
return *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>( this );
}
bool operator==( FramebufferAttachmentImageInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
&& ( usage == rhs.usage )
&& ( width == rhs.width )
&& ( height == rhs.height )
&& ( layerCount == rhs.layerCount )
&& ( viewFormatCount == rhs.viewFormatCount )
&& ( pViewFormats == rhs.pViewFormats );
}
bool operator!=( FramebufferAttachmentImageInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR;
public:
const void* pNext = nullptr;
ImageCreateFlags flags;
ImageUsageFlags usage;
uint32_t width;
uint32_t height;
uint32_t layerCount;
uint32_t viewFormatCount;
const Format* pViewFormats;
};
static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "struct and wrapper have different size!" );
struct FramebufferAttachmentsCreateInfoKHR
{
FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
: attachmentImageInfoCount( attachmentImageInfoCount_ )
, pAttachmentImageInfos( pAttachmentImageInfos_ )
{}
FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
{
*reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
}
FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
{
*reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
return *this;
}
FramebufferAttachmentsCreateInfoKHR & setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
FramebufferAttachmentsCreateInfoKHR & setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ )
{
attachmentImageInfoCount = attachmentImageInfoCount_;
return *this;
}
FramebufferAttachmentsCreateInfoKHR & setPAttachmentImageInfos( const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ )
{
pAttachmentImageInfos = pAttachmentImageInfos_;
return *this;
}
operator VkFramebufferAttachmentsCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfoKHR*>( this );
}
operator VkFramebufferAttachmentsCreateInfoKHR &()
{
return *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>( this );
}
bool operator==( FramebufferAttachmentsCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( attachmentImageInfoCount == rhs.attachmentImageInfoCount )
&& ( pAttachmentImageInfos == rhs.pAttachmentImageInfos );
}
bool operator!=( FramebufferAttachmentsCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR;
public:
const void* pNext = nullptr;
uint32_t attachmentImageInfoCount;
const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
};
static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "struct and wrapper have different size!" );
struct FramebufferCreateInfo
{
FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(),
@ -39162,6 +39500,66 @@ namespace VULKAN_HPP_NAMESPACE
};
static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceImagelessFramebufferFeaturesKHR
{
PhysicalDeviceImagelessFramebufferFeaturesKHR( Bool32 imagelessFramebuffer_ = 0 )
: imagelessFramebuffer( imagelessFramebuffer_ )
{}
PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
{
*reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
}
PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
{
*reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
return *this;
}
PhysicalDeviceImagelessFramebufferFeaturesKHR & setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
PhysicalDeviceImagelessFramebufferFeaturesKHR & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ )
{
imagelessFramebuffer = imagelessFramebuffer_;
return *this;
}
operator VkPhysicalDeviceImagelessFramebufferFeaturesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>( this );
}
operator VkPhysicalDeviceImagelessFramebufferFeaturesKHR &()
{
return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>( this );
}
bool operator==( PhysicalDeviceImagelessFramebufferFeaturesKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( imagelessFramebuffer == rhs.imagelessFramebuffer );
}
bool operator!=( PhysicalDeviceImagelessFramebufferFeaturesKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR;
public:
void* pNext = nullptr;
Bool32 imagelessFramebuffer;
};
static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceInlineUniformBlockFeaturesEXT
{
PhysicalDeviceInlineUniformBlockFeaturesEXT( Bool32 inlineUniformBlock_ = 0,
@ -44979,6 +45377,76 @@ namespace VULKAN_HPP_NAMESPACE
};
static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
struct RenderPassAttachmentBeginInfoKHR
{
RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
const ImageView* pAttachments_ = nullptr )
: attachmentCount( attachmentCount_ )
, pAttachments( pAttachments_ )
{}
RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs )
{
*reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
}
RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs )
{
*reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
return *this;
}
RenderPassAttachmentBeginInfoKHR & setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
RenderPassAttachmentBeginInfoKHR & setAttachmentCount( uint32_t attachmentCount_ )
{
attachmentCount = attachmentCount_;
return *this;
}
RenderPassAttachmentBeginInfoKHR & setPAttachments( const ImageView* pAttachments_ )
{
pAttachments = pAttachments_;
return *this;
}
operator VkRenderPassAttachmentBeginInfoKHR const&() const
{
return *reinterpret_cast<const VkRenderPassAttachmentBeginInfoKHR*>( this );
}
operator VkRenderPassAttachmentBeginInfoKHR &()
{
return *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>( this );
}
bool operator==( RenderPassAttachmentBeginInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( attachmentCount == rhs.attachmentCount )
&& ( pAttachments == rhs.pAttachments );
}
bool operator!=( RenderPassAttachmentBeginInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
public:
const void* pNext = nullptr;
uint32_t attachmentCount;
const ImageView* pAttachments;
};
static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" );
struct RenderPassBeginInfo
{
RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(),
@ -57619,6 +58087,7 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageFormatProperties2, FilterCubicImageViewImageFormatPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<FramebufferCreateInfo, FramebufferAttachmentsCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierListCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
@ -57698,6 +58167,8 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceIDProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageViewImageFormatInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
@ -57790,6 +58261,7 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassAttachmentBeginInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfo>{ enum { value = true }; };

48
include/vulkan/vulkan_core.h
View File

@ -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 113
#define VK_HEADER_VERSION 114
#define VK_NULL_HANDLE 0
@ -351,6 +351,10 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = 1000108000,
VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = 1000108001,
VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = 1000108002,
VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = 1000108003,
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
@ -1709,6 +1713,11 @@ typedef enum VkDescriptorPoolCreateFlagBits {
} VkDescriptorPoolCreateFlagBits;
typedef VkFlags VkDescriptorPoolCreateFlags;
typedef VkFlags VkDescriptorPoolResetFlags;
typedef enum VkFramebufferCreateFlagBits {
VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = 0x00000001,
VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkFramebufferCreateFlagBits;
typedef VkFlags VkFramebufferCreateFlags;
typedef VkFlags VkRenderPassCreateFlags;
@ -5602,6 +5611,43 @@ VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
#endif
#define VK_KHR_imageless_framebuffer 1
#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
typedef struct VkPhysicalDeviceImagelessFramebufferFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 imagelessFramebuffer;
} VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
typedef struct VkFramebufferAttachmentImageInfoKHR {
VkStructureType sType;
const void* pNext;
VkImageCreateFlags flags;
VkImageUsageFlags usage;
uint32_t width;
uint32_t height;
uint32_t layerCount;
uint32_t viewFormatCount;
const VkFormat* pViewFormats;
} VkFramebufferAttachmentImageInfoKHR;
typedef struct VkFramebufferAttachmentsCreateInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t attachmentImageInfoCount;
const VkFramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
} VkFramebufferAttachmentsCreateInfoKHR;
typedef struct VkRenderPassAttachmentBeginInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t attachmentCount;
const VkImageView* pAttachments;
} VkRenderPassAttachmentBeginInfoKHR;
#define VK_KHR_create_renderpass2 1
#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"

242
registry/validusage.json
View File

File diff suppressed because one or more lines are too long

60
registry/vk.xml
View File

@ -154,7 +154,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> 113</type>
#define <name>VK_HEADER_VERSION</name> 114</type>
<type category="define">
#define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@ -199,7 +199,7 @@ typedef void <name>CAMetalLayer</name>;
<type name="int"/>
<comment>Bitmask types</comment>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type>
<type requires="VkFramebufferCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPoolCreateFlags</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkRenderPassCreateFlags</name>;</type>
<type requires="VkSamplerCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSamplerCreateFlags</name>;</type>
@ -3808,6 +3808,34 @@ typedef void <name>CAMetalLayer</name>;
<member><type>VkBool32</type> <name>filterCubic</name></member> <!-- The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT -->
<member><type>VkBool32</type> <name>filterCubicMinmax</name> </member> <!-- The combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max -->
</type>
<type category="struct" name="VkPhysicalDeviceImagelessFramebufferFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>imagelessFramebuffer</name></member>
</type>
<type category="struct" name="VkFramebufferAttachmentsCreateInfoKHR" structextends="VkFramebufferCreateInfo">
<member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>uint32_t</type> <name>attachmentImageInfoCount</name></member>
<member len="attachmentImageInfoCount">const <type>VkFramebufferAttachmentImageInfoKHR</type>* <name>pAttachmentImageInfos</name></member>
</type>
<type category="struct" name="VkFramebufferAttachmentImageInfoKHR">
<member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkImageCreateFlags</type> <name>flags</name><comment>Image creation flags</comment></member>
<member><type>VkImageUsageFlags</type> <name>usage</name><comment>Image usage flags</comment></member>
<member><type>uint32_t</type> <name>width</name></member>
<member><type>uint32_t</type> <name>height</name></member>
<member><type>uint32_t</type> <name>layerCount</name></member>
<member optional="true"><type>uint32_t</type> <name>viewFormatCount</name></member>
<member len="viewFormatCount">const <type>VkFormat</type>* <name>pViewFormats</name></member>
</type>
<type category="struct" name="VkRenderPassAttachmentBeginInfoKHR" structextends="VkRenderPassBeginInfo">
<member values="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure -->
<member optional="true"><type>uint32_t</type> <name>attachmentCount</name></member>
<member len="attachmentCount">const <type>VkImageView</type>* <name>pAttachments</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceCooperativeMatrixFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member><type>void</type>* <name>pNext</name></member>
@ -5191,6 +5219,8 @@ typedef void <name>CAMetalLayer</name>;
<enum value="1" name="VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD"/>
<enum value="2" name="VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD"/>
</enums>
<enums name="VkFramebufferCreateFlagBits" type="bitmask">
</enums>
<enums name="VkScopeNV" type="enum">
<enum value="1" name="VK_SCOPE_DEVICE_NV"/>
<enum value="2" name="VK_SCOPE_WORKGROUP_NV"/>
@ -9353,10 +9383,18 @@ typedef void <name>CAMetalLayer</name>;
<enum value="&quot;VK_IMG_extension_108&quot;" name="VK_IMG_EXTENSION_108_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_IMG_extension_109" number="109" author="IMG" contact="Michael Worcester @michaelworcester" supported="disabled">
<extension name="VK_KHR_imageless_framebuffer" requires="VK_KHR_maintenance2,VK_KHR_image_format_list" number="109" author="KHR" contact="Tobias Hector @tobias" type="device" supported="vulkan">
<require>
<enum value="0" name="VK_IMG_EXTENSION_109_SPEC_VERSION"/>
<enum value="&quot;VK_IMG_extension_109&quot;" name="VK_IMG_EXTENSION_109_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_imageless_framebuffer&quot;" name="VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME"/>
<type name="VkPhysicalDeviceImagelessFramebufferFeaturesKHR"/>
<type name="VkFramebufferAttachmentsCreateInfoKHR"/>
<type name="VkRenderPassAttachmentBeginInfoKHR"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR"/>
<enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR"/>
<enum bitpos="0" extends="VkFramebufferCreateFlagBits" name="VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR"/>
</require>
</extension>
<extension name="VK_KHR_create_renderpass2" requires="VK_KHR_multiview,VK_KHR_maintenance2" number="110" contact="Tobias Hector @tobias" type="device" supported="vulkan">
@ -11136,5 +11174,17 @@ typedef void <name>CAMetalLayer</name>;
<type name="VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT"/>
</require>
</extension>
<extension name="VK_QCOM_extension_283" number="283" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_283_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_283&quot;" name="VK_QCOM_extension_283"/>
</require>
</extension>
<extension name="VK_EXT_extension_284" number="284" type="device" author="EXT" contact="Samuel Pitoiset @hakzsam" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_284_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_284&quot;" name="VK_EXT_extension_284"/>
</require>
</extension>
</extensions>
</registry>