BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.311

Browse source
This commit is contained in:
Jon Leech 2025-03-20 23:32:16 -07:00 • committed by Jon Leech
parent d64e9e156a
commit 78c359741d
22 changed files with 1889 additions and 1257 deletions
Download patch file Download diff file Expand all files Collapse all files

48
include/vulkan/vulkan.cppm
View file

@ -1555,6 +1555,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;
//=== VK_KHR_shader_bfloat16 ===
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
@ -2734,6 +2738,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -3723,6 +3731,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
//=== VK_KHR_shader_bfloat16 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
@ -4402,11 +4413,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;
//=== VK_QCOM_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
//=== VK_NV_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
@ -4820,6 +4826,15 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
//===============
//=== HANDLEs ===
//===============
@ -5197,7 +5212,6 @@ export namespace VULKAN_HPP_NAMESPACE
//======================================
using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions;
using VULKAN_HPP_NAMESPACE::getDeviceExtensions;
using VULKAN_HPP_NAMESPACE::getExtensionDepends;
using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy;
using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy;
using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo;
@ -6771,6 +6785,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;
//=== VK_KHR_shader_bfloat16 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>;
//=== VK_EXT_sample_locations ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>;
@ -7831,14 +7849,6 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>;
//=== VK_QCOM_fragment_density_map_offset ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>;
//=== VK_NV_copy_memory_indirect ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
@ -8505,6 +8515,16 @@ export namespace std
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>;
//=================================================================
//=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
//=================================================================

128
include/vulkan/vulkan.hpp
View file

@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 310, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 311, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -6219,6 +6219,13 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo );
}
};
inline DispatchLoaderStatic & getDispatchLoaderStatic()
@ -7799,6 +7806,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
//=== VK_KHR_shader_bfloat16 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION;
//=== VK_EXT_sample_locations ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
@ -8973,6 +8984,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -12193,6 +12208,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_shader_bfloat16 ===
template <>
struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_sample_locations ===
template <>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
@ -15672,43 +15706,6 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_fragment_density_map_offset ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
{
enum
{
value = true
};
};
//=== VK_NV_copy_memory_indirect ===
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>
@ -18004,6 +18001,52 @@ namespace VULKAN_HPP_NAMESPACE
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, SubpassEndInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, RenderingEndInfoEXT>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail
@ -19335,6 +19378,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
public:
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@ -20877,6 +20923,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandlePropertiesEXT =
PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) );
}
void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
@ -22044,6 +22093,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
}
template <typename DynamicLoader>

69
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 310
#define VK_HEADER_VERSION 311
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -658,6 +658,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004,
#endif
VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000,
VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
@ -1024,9 +1025,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002,
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003,
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
@ -1243,6 +1241,10 @@ typedef enum VkStructureType {
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001,
#endif
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001,
VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002,
VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
// VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@ -1453,6 +1455,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@ -2502,14 +2507,15 @@ typedef enum VkImageCreateFlagBits {
VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000,
VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000,
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;
typedef VkFlags VkImageCreateFlags;
@ -10711,6 +10717,20 @@ typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
// VK_KHR_shader_bfloat16 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_shader_bfloat16 1
#define VK_KHR_SHADER_BFLOAT16_SPEC_VERSION 1
#define VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME "VK_KHR_shader_bfloat16"
typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 shaderBFloat16Type;
VkBool32 shaderBFloat16DotProduct;
VkBool32 shaderBFloat16CooperativeMatrix;
} VkPhysicalDeviceShaderBfloat16FeaturesKHR;
// VK_KHR_relaxed_block_layout is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_relaxed_block_layout 1
#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
@ -12191,6 +12211,7 @@ typedef enum VkComponentTypeKHR {
VK_COMPONENT_TYPE_UINT16_KHR = 8,
VK_COMPONENT_TYPE_UINT32_KHR = 9,
VK_COMPONENT_TYPE_UINT64_KHR = 10,
VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000,
VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000,
VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002,
@ -18882,26 +18903,32 @@ typedef struct VkRenderPassStripeSubmitInfoARM {
// VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_fragment_density_map_offset 1
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 fragmentDensityMapOffset;
} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
VkStructureType sType;
void* pNext;
VkExtent2D fragmentDensityOffsetGranularity;
} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t fragmentDensityOffsetCount;
const VkOffset2D* pFragmentDensityOffsets;
} VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
} VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
@ -21386,6 +21413,24 @@ typedef struct VkPhysicalDevicePresentMeteringFeaturesNV {
// VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_fragment_density_map_offset 1
#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset"
typedef struct VkRenderingEndInfoEXT {
VkStructureType sType;
const void* pNext;
} VkRenderingEndInfoEXT;
typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT* pRenderingEndInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(
VkCommandBuffer commandBuffer,
const VkRenderingEndInfoEXT* pRenderingEndInfo);
#endif
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

21
include/vulkan/vulkan_enums.hpp
View file

@ -988,6 +988,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eAttachmentSampleCountInfoAMD = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
eAttachmentSampleCountInfoNV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV,
ePhysicalDeviceShaderBfloat16FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR,
eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
@ -1360,9 +1361,6 @@ namespace VULKAN_HPP_NAMESPACE
eRenderPassStripeBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM,
eRenderPassStripeInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM,
eRenderPassStripeSubmitInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM,
ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
ePhysicalDeviceCopyMemoryIndirectFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
ePhysicalDeviceMemoryDecompressionFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
@ -1587,8 +1585,15 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV,
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
eRenderPassFragmentDensityMapOffsetEndInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT
};
// wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
@ -2087,8 +2092,9 @@ namespace VULKAN_HPP_NAMESPACE
eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT,
eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT,
e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,
eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM,
eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR
eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR,
eFragmentDensityMapOffsetEXT = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM
};
// wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html
@ -2105,7 +2111,7 @@ namespace VULKAN_HPP_NAMESPACE
ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV |
ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT |
ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT |
ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM | ImageCreateFlagBits::eVideoProfileIndependentKHR;
ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT;
};
// wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html
@ -8152,6 +8158,7 @@ namespace VULKAN_HPP_NAMESPACE
eUint16 = VK_COMPONENT_TYPE_UINT16_KHR,
eUint32 = VK_COMPONENT_TYPE_UINT32_KHR,
eUint64 = VK_COMPONENT_TYPE_UINT64_KHR,
eBfloat16 = VK_COMPONENT_TYPE_BFLOAT16_KHR,
eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV,
eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV,
eFloatE4M3NV = VK_COMPONENT_TYPE_FLOAT_E4M3_NV,

19
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -178,6 +178,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_AMD_shader_fragment_mask",
"VK_EXT_inline_uniform_block",
"VK_EXT_shader_stencil_export",
"VK_KHR_shader_bfloat16",
"VK_EXT_sample_locations",
"VK_KHR_relaxed_block_layout",
"VK_KHR_get_memory_requirements2",
@ -469,8 +470,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering"
"VK_NV_present_metering",
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
"VK_EXT_fragment_density_map_offset"
};
return deviceExtensions;
}
@ -653,6 +655,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_maintenance4", "VK_VERSION_1_3" },
{ "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
{ "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
{ "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
{ "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
{ "VK_KHR_maintenance5", "VK_VERSION_1_4" },
{ "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
@ -1126,6 +1129,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_KHR_depth_clamp_zero_one";
}
if ( extension == "VK_QCOM_fragment_density_map_offset" )
{
return "VK_EXT_fragment_density_map_offset";
}
if ( extension == "VK_EXT_pipeline_protected_access" )
{
return "VK_VERSION_1_4";
@ -1241,8 +1248,8 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_AMDX_shader_enqueue" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) ||
( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) ||
@ -1392,7 +1399,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
;
|| ( extension == "VK_EXT_fragment_density_map_offset" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@ -1503,8 +1510,8 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) ||
( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_EXT_pipeline_protected_access" ) ||
( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" );
}

27
include/vulkan/vulkan_funcs.hpp
View file

@ -31501,5 +31501,32 @@ namespace VULKAN_HPP_NAMESPACE
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdEndRendering2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingEndInfoEXT *>( pRenderingEndInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset>" );
# endif
d.vkCmdEndRendering2EXT(
m_commandBuffer, reinterpret_cast<const VkRenderingEndInfoEXT *>( static_cast<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT *>( renderingEndInfo ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
} // namespace VULKAN_HPP_NAMESPACE
#endif

30
include/vulkan/vulkan_handles.hpp
View file

@ -949,6 +949,9 @@ namespace VULKAN_HPP_NAMESPACE
struct AttachmentSampleCountInfoAMD;
using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
//=== VK_KHR_shader_bfloat16 ===
struct PhysicalDeviceShaderBfloat16FeaturesKHR;
//=== VK_EXT_sample_locations ===
struct SampleLocationEXT;
struct SampleLocationsInfoEXT;
@ -1628,11 +1631,6 @@ namespace VULKAN_HPP_NAMESPACE
struct RenderPassStripeInfoARM;
struct RenderPassStripeSubmitInfoARM;
//=== VK_QCOM_fragment_density_map_offset ===
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
//=== VK_NV_copy_memory_indirect ===
struct CopyMemoryIndirectCommandNV;
struct CopyMemoryToImageIndirectCommandNV;
@ -2046,6 +2044,15 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDevicePresentMeteringFeaturesNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
struct RenderingEndInfoEXT;
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
struct RenderPassFragmentDensityMapOffsetEndInfoEXT;
using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
//===================================
//=== HANDLE forward declarations ===
//===================================
@ -7797,6 +7804,19 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer;

84
include/vulkan/vulkan_hash.hpp
View file

@ -9761,30 +9761,30 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const
VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity );
return seed;
}
};
@ -12371,6 +12371,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
{
@ -15482,6 +15498,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
{
@ -15675,6 +15706,18 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const & renderingEndInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.pNext );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
{
@ -16407,21 +16450,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
{

25
include/vulkan/vulkan_raii.hpp
View file

@ -1843,6 +1843,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
}
public:
@ -2790,6 +2793,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0;
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
};
} // namespace detail
@ -7853,6 +7859,12 @@ namespace VULKAN_HPP_NAMESPACE
void executeGeneratedCommandsEXT( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
@ -27213,6 +27225,19 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
VULKAN_HPP_INLINE void
CommandBuffer::endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset>" );
getDispatcher()->vkCmdEndRendering2EXT(
static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkRenderingEndInfoEXT *>( static_cast<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT *>( renderingEndInfo ) ) );
}
//====================
//=== RAII Helpers ===
//====================

65
include/vulkan/vulkan_static_assertions.hpp
View file

@ -3611,6 +3611,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Attachme
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>::value,
"AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" );
//=== VK_KHR_shader_bfloat16 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
"PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" );
//=== VK_EXT_sample_locations ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
@ -6595,31 +6604,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>::value,
"RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" );
//=== VK_QCOM_fragment_density_map_offset ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
"PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
"PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
"SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
//=== VK_NV_copy_memory_indirect ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
@ -8547,4 +8531,35 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
"PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT ) == sizeof( VkRenderingEndInfoEXT ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value,
"RenderingEndInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
"PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
"PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) ==
sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
"RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" );
#endif

634
include/vulkan/vulkan_structs.hpp
View file

@ -81768,49 +81768,49 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.html
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityMapOffset{ fragmentDensityMapOffset_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs ) )
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *>( &rhs ) )
{
}
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &
operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &
setFragmentDensityMapOffset( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityMapOffset = fragmentDensityMapOffset_;
@ -81818,24 +81818,24 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -81851,9 +81851,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default;
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -81862,77 +81862,79 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
{
using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.html
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetGranularity{ fragmentDensityOffsetGranularity_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs ) )
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *>( &rhs ) )
{
}
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &
operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -81948,9 +81950,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default;
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -81959,24 +81961,26 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
{
using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
};
using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html
struct PhysicalDeviceFragmentDensityMapPropertiesEXT
@ -101106,6 +101110,141 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
// wrapper struct for struct VkPhysicalDeviceShaderBfloat16FeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderBfloat16FeaturesKHR.html
struct PhysicalDeviceShaderBfloat16FeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderBfloat16FeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type_ = {},
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct_ = {},
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, shaderBFloat16Type{ shaderBFloat16Type_ }
, shaderBFloat16DotProduct{ shaderBFloat16DotProduct_ }
, shaderBFloat16CooperativeMatrix{ shaderBFloat16CooperativeMatrix_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderBfloat16FeaturesKHR( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderBfloat16FeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderBfloat16FeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16Type( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16Type = shaderBFloat16Type_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16DotProduct( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16DotProduct = shaderBFloat16DotProduct_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16CooperativeMatrix( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, shaderBFloat16Type, shaderBFloat16DotProduct, shaderBFloat16CooperativeMatrix );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderBfloat16FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBFloat16Type == rhs.shaderBFloat16Type ) &&
( shaderBFloat16DotProduct == rhs.shaderBFloat16DotProduct ) && ( shaderBFloat16CooperativeMatrix == rhs.shaderBFloat16CooperativeMatrix );
# endif
}
bool operator!=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR>
{
using Type = PhysicalDeviceShaderBfloat16FeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceShaderClockFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html
struct PhysicalDeviceShaderClockFeaturesKHR
@ -127068,6 +127207,149 @@ namespace VULKAN_HPP_NAMESPACE
using Type = RenderPassFragmentDensityMapCreateInfoEXT;
};
// wrapper struct for struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapOffsetEndInfoEXT.html
struct RenderPassFragmentDensityMapOffsetEndInfoEXT
{
using NativeType = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( uint32_t fragmentDensityOffsetCount_ = {},
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ }
, pFragmentDensityOffsets{ pFragmentDensityOffsets_ }
{
}
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
RenderPassFragmentDensityMapOffsetEndInfoEXT( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: RenderPassFragmentDensityMapOffsetEndInfoEXT( *reinterpret_cast<RenderPassFragmentDensityMapOffsetEndInfoEXT const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
RenderPassFragmentDensityMapOffsetEndInfoEXT(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_, const void * pNext_ = nullptr )
: pNext( pNext_ )
, fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
, pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT &
setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT &
setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
pFragmentDensityOffsets = pFragmentDensityOffsets_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
RenderPassFragmentDensityMapOffsetEndInfoEXT & setFragmentDensityOffsets(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
pFragmentDensityOffsets = fragmentDensityOffsets_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const VULKAN_HPP_NAMESPACE::Offset2D * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassFragmentDensityMapOffsetEndInfoEXT const & ) const = default;
#else
bool operator==( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets );
# endif
}
bool operator!=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT;
const void * pNext = {};
uint32_t fragmentDensityOffsetCount = {};
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {};
};
template <>
struct CppType<StructureType, StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT>
{
using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT;
};
using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
// wrapper struct for struct VkRenderPassInputAttachmentAspectCreateInfo, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html
struct RenderPassInputAttachmentAspectCreateInfo
@ -129029,6 +129311,101 @@ namespace VULKAN_HPP_NAMESPACE
using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
// wrapper struct for struct VkRenderingEndInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingEndInfoEXT.html
struct RenderingEndInfoEXT
{
using NativeType = VkRenderingEndInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingEndInfoEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RenderingEndInfoEXT( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {}
VULKAN_HPP_CONSTEXPR RenderingEndInfoEXT( RenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
RenderingEndInfoEXT( VkRenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingEndInfoEXT( *reinterpret_cast<RenderingEndInfoEXT const *>( &rhs ) )
{
}
RenderingEndInfoEXT & operator=( RenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
RenderingEndInfoEXT & operator=( VkRenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkRenderingEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkRenderingEndInfoEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderingEndInfoEXT const & ) const = default;
#else
bool operator==( RenderingEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
# endif
}
bool operator!=( RenderingEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingEndInfoEXT;
const void * pNext = {};
};
template <>
struct CppType<StructureType, StructureType::eRenderingEndInfoEXT>
{
using Type = RenderingEndInfoEXT;
};
// wrapper struct for struct VkRenderingFragmentDensityMapAttachmentInfoEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html
struct RenderingFragmentDensityMapAttachmentInfoEXT
@ -135448,147 +135825,6 @@ namespace VULKAN_HPP_NAMESPACE
using SubpassEndInfoKHR = SubpassEndInfo;
// wrapper struct for struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html
struct SubpassFragmentDensityMapOffsetEndInfoQCOM
{
using NativeType = VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( uint32_t fragmentDensityOffsetCount_ = {},
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ }
, pFragmentDensityOffsets{ pFragmentDensityOffsets_ }
{
}
VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
SubpassFragmentDensityMapOffsetEndInfoQCOM( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: SubpassFragmentDensityMapOffsetEndInfoQCOM( *reinterpret_cast<SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
SubpassFragmentDensityMapOffsetEndInfoQCOM(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_, const void * pNext_ = nullptr )
: pNext( pNext_ )
, fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
, pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
SubpassFragmentDensityMapOffsetEndInfoQCOM & operator=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
SubpassFragmentDensityMapOffsetEndInfoQCOM & operator=( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
pFragmentDensityOffsets = pFragmentDensityOffsets_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
SubpassFragmentDensityMapOffsetEndInfoQCOM & setFragmentDensityOffsets(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
pFragmentDensityOffsets = fragmentDensityOffsets_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const VULKAN_HPP_NAMESPACE::Offset2D * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default;
#else
bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets );
# endif
}
bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
const void * pNext = {};
uint32_t fragmentDensityOffsetCount = {};
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {};
};
template <>
struct CppType<StructureType, StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM>
{
using Type = SubpassFragmentDensityMapOffsetEndInfoQCOM;
};
// wrapper struct for struct VkSubpassResolvePerformanceQueryEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassResolvePerformanceQueryEXT.html
struct SubpassResolvePerformanceQueryEXT

807
include/vulkan/vulkan_to_string.hpp
View file

File diff suppressed because it is too large Load diff