yuzu/Vulkan-Headers
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers synced 2024-11-21 14:29:07 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Update for Vulkan-Docs 1.3.241

Browse source
This commit is contained in:
Jon Leech 2023-02-16 05:30:42 -08:00 committed by Jon Leech
parent e8b8e06d09
commit bd6443d28f
47 changed files with 3638 additions and 968 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/vk_video/vulkan_video_codec_h264std.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H264STD_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codec_h264std_decode.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codec_h264std_encode.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codec_h265std.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H265STD_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codec_h265std_decode.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codec_h265std_encode.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vk_video/vulkan_video_codecs_common.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VIDEO_CODECS_COMMON_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vk_platform.h
View file

@ -2,7 +2,7 @@
// File: vk_platform.h
//
/*
** Copyright 2014-2022 The Khronos Group Inc.
** Copyright 2014-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

10
include/vulkan/vulkan.h
View file

@ -2,7 +2,7 @@
#define VULKAN_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/
@ -84,6 +84,14 @@
#include "vulkan_screen.h"
#endif
#ifdef VK_USE_PLATFORM_SCI
#include <nvscisync.h>
#include <nvscibuf.h>
#include "vulkan_sci.h"
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
#include "vulkan_beta.h"
#endif

113
include/vulkan/vulkan.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 240, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 241, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for non-dispatchable 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
@ -3658,6 +3658,16 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
}
void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
}
void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
}
//=== VK_EXT_hdr_metadata ===
void vkSetHdrMetadataEXT( VkDevice device,
@ -4401,6 +4411,14 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_scissor_exclusive ===
void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables );
}
void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
@ -11809,6 +11827,42 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_ARM_shader_core_properties ===
template <>
struct StructExtends<PhysicalDeviceShaderCorePropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_image_sliced_view_of_3d ===
template <>
struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageViewSlicedCreateInfoEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
//=== VK_VALVE_descriptor_set_host_mapping ===
template <>
struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2>
@ -12409,6 +12463,40 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_multiview_per_view_render_areas ===
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderingInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
@ -12992,7 +13080,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
//=== VK_EXT_discard_rectangles ===
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0;
//=== VK_EXT_hdr_metadata ===
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
@ -13160,7 +13250,8 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
//=== VK_NV_scissor_exclusive ===
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0;
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
//=== VK_NV_device_diagnostic_checkpoints ===
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
@ -14120,7 +14211,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
//=== VK_EXT_discard_rectangles ===
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) );
vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) );
//=== VK_EXT_hdr_metadata ===
vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
@ -14336,7 +14429,8 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
//=== VK_NV_scissor_exclusive ===
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorEnableNV" ) );
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
//=== VK_NV_device_diagnostic_checkpoints ===
vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
@ -15170,7 +15264,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
//=== VK_EXT_discard_rectangles ===
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
//=== VK_EXT_hdr_metadata ===
vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
@ -15344,7 +15440,8 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
//=== VK_NV_scissor_exclusive ===
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) );
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
//=== VK_NV_device_diagnostic_checkpoints ===
vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );

2
include/vulkan/vulkan_android.h
View file

@ -2,7 +2,7 @@
#define VULKAN_ANDROID_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_beta.h
View file

@ -2,7 +2,7 @@
#define VULKAN_BETA_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

113
include/vulkan/vulkan_core.h
View file

@ -2,7 +2,7 @@
#define VULKAN_CORE_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/
@ -22,7 +22,7 @@ extern "C" {
#define VK_VERSION_1_0 1
#include "vk_platform.h"
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* (object);
#ifndef VK_USE_64_BIT_PTR_DEFINES
@ -52,43 +52,43 @@ extern "C" {
#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
#if (VK_USE_64_BIT_PTR_DEFINES==1)
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object);
#else
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t (object);
#endif
#endif
// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
#define VK_MAKE_VERSION(major, minor, patch) \
((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
#define VK_MAKE_API_VERSION(variant, major, minor, patch) \
((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch)))
// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
#define VK_MAKE_API_VERSION(variant, major, minor, patch) \
((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
// Vulkan 1.0 version number
#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 240
#define VK_HEADER_VERSION 241
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
#define VK_MAKE_VERSION(major, minor, patch) \
((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch)))
// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U)
// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU)
// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)
#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U)
#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU)
#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU)
#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
typedef uint32_t VkBool32;
typedef uint64_t VkDeviceAddress;
@ -951,6 +951,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000,
VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000,
VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002,
@ -1002,6 +1005,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000,
VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001,
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 = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@ -1806,10 +1811,13 @@ typedef enum VkDynamicState {
VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004,
VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001,
VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002,
VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000,
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
@ -11165,7 +11173,7 @@ typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
#define VK_EXT_discard_rectangles 1
#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 2
#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
typedef enum VkDiscardRectangleModeEXT {
@ -11190,6 +11198,8 @@ typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
} VkPipelineDiscardRectangleStateCreateInfoEXT;
typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable);
typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
@ -11197,6 +11207,14 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VkRect2D* pDiscardRectangles);
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT(
VkCommandBuffer commandBuffer,
VkBool32 discardRectangleEnable);
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT(
VkCommandBuffer commandBuffer,
VkDiscardRectangleModeEXT discardRectangleMode);
#endif
@ -12617,7 +12635,7 @@ typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
#define VK_NV_scissor_exclusive 1
#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 2
#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
VkStructureType sType;
@ -12632,9 +12650,16 @@ typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
VkBool32 exclusiveScissor;
} VkPhysicalDeviceExclusiveScissorFeaturesNV;
typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables);
typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV(
VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkBool32* pExclusiveScissorEnables);
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
@ -15496,6 +15521,38 @@ VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(
#endif
#define VK_ARM_shader_core_properties 1
#define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
#define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties"
typedef struct VkPhysicalDeviceShaderCorePropertiesARM {
VkStructureType sType;
void* pNext;
uint32_t pixelRate;
uint32_t texelRate;
uint32_t fmaRate;
} VkPhysicalDeviceShaderCorePropertiesARM;
#define VK_EXT_image_sliced_view_of_3d 1
#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1
#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d"
#define VK_REMAINING_3D_SLICES_EXT (~0U)
typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 imageSlicedViewOf3D;
} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
typedef struct VkImageViewSlicedCreateInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t sliceOffset;
uint32_t sliceCount;
} VkImageViewSlicedCreateInfoEXT;
#define VK_VALVE_descriptor_set_host_mapping 1
#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1
#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping"
@ -16414,6 +16471,24 @@ typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
#define VK_QCOM_multiview_per_view_render_areas 1
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas"
typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
VkStructureType sType;
void* pNext;
VkBool32 multiviewPerViewRenderAreas;
} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
VkStructureType sType;
const void* pNext;
uint32_t perViewRenderAreaCount;
const VkRect2D* pPerViewRenderAreas;
} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"

2
include/vulkan/vulkan_directfb.h
View file

@ -2,7 +2,7 @@
#define VULKAN_DIRECTFB_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

10
include/vulkan/vulkan_enums.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -831,6 +831,9 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceBorderColorSwizzleFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
eSamplerBorderColorComponentMappingCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
ePhysicalDeviceShaderCorePropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM,
ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT,
eImageViewSlicedCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT,
ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
eDescriptorSetBindingReferenceVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
eDescriptorSetLayoutHostMappingInfoVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
@ -882,6 +885,8 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceShaderCoreBuiltinsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM,
ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM,
eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM,
eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
@ -2366,10 +2371,13 @@ namespace VULKAN_HPP_NAMESPACE
ePrimitiveRestartEnable = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
eDiscardRectangleEnableEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT,
eDiscardRectangleModeEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT,
eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
eRayTracingPipelineStackSizeKHR = VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR,
eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
eExclusiveScissorEnableNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV,
eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR,
eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT,

2
include/vulkan/vulkan_format_traits.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//

2
include/vulkan/vulkan_fuchsia.h
View file

@ -2,7 +2,7 @@
#define VULKAN_FUCHSIA_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

43
include/vulkan/vulkan_funcs.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -12138,6 +12138,22 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdSetDiscardRectangleEnableEXT( m_commandBuffer, static_cast<VkBool32>( discardRectangleEnable ) );
}
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdSetDiscardRectangleModeEXT( m_commandBuffer, static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) );
}
//=== VK_EXT_hdr_metadata ===
template <typename Dispatch>
@ -15727,6 +15743,31 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_scissor_exclusive ===
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdSetExclusiveScissorEnableNV(
m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkBool32 *>( pExclusiveScissorEnables ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_INLINE void
CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdSetExclusiveScissorEnableNV(
m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,

2
include/vulkan/vulkan_ggp.h
View file

@ -2,7 +2,7 @@
#define VULKAN_GGP_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

774
include/vulkan/vulkan_handles.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -1453,6 +1453,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_pageable_device_local_memory ===
struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
//=== VK_ARM_shader_core_properties ===
struct PhysicalDeviceShaderCorePropertiesARM;
//=== VK_EXT_image_sliced_view_of_3d ===
struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
struct ImageViewSlicedCreateInfoEXT;
//=== VK_VALVE_descriptor_set_host_mapping ===
struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
struct DescriptorSetBindingReferenceVALVE;
@ -1564,6 +1571,438 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_pipeline_library_group_handles ===
struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
//=== VK_QCOM_multiview_per_view_render_areas ===
struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
//===================================
//=== HANDLE forward declarations ===
//===================================
//=== VK_VERSION_1_0 ===
class Instance;
class PhysicalDevice;
class Device;
class Queue;
class DeviceMemory;
class Fence;
class Semaphore;
class Event;
class QueryPool;
class Buffer;
class BufferView;
class Image;
class ImageView;
class ShaderModule;
class PipelineCache;
class Pipeline;
class PipelineLayout;
class Sampler;
class DescriptorPool;
class DescriptorSet;
class DescriptorSetLayout;
class Framebuffer;
class RenderPass;
class CommandPool;
class CommandBuffer;
//=== VK_VERSION_1_1 ===
class SamplerYcbcrConversion;
class DescriptorUpdateTemplate;
//=== VK_VERSION_1_3 ===
class PrivateDataSlot;
//=== VK_KHR_surface ===
class SurfaceKHR;
//=== VK_KHR_swapchain ===
class SwapchainKHR;
//=== VK_KHR_display ===
class DisplayKHR;
class DisplayModeKHR;
//=== VK_EXT_debug_report ===
class DebugReportCallbackEXT;
//=== VK_KHR_video_queue ===
class VideoSessionKHR;
class VideoSessionParametersKHR;
//=== VK_NVX_binary_import ===
class CuModuleNVX;
class CuFunctionNVX;
//=== VK_EXT_debug_utils ===
class DebugUtilsMessengerEXT;
//=== VK_KHR_acceleration_structure ===
class AccelerationStructureKHR;
//=== VK_EXT_validation_cache ===
class ValidationCacheEXT;
//=== VK_NV_ray_tracing ===
class AccelerationStructureNV;
//=== VK_INTEL_performance_query ===
class PerformanceConfigurationINTEL;
//=== VK_KHR_deferred_host_operations ===
class DeferredOperationKHR;
//=== VK_NV_device_generated_commands ===
class IndirectCommandsLayoutNV;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
class BufferCollectionFUCHSIA;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_EXT_opacity_micromap ===
class MicromapEXT;
//=== VK_NV_optical_flow ===
class OpticalFlowSessionNV;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
//======================
//=== UNIQUE HANDLEs ===
//======================
//=== VK_VERSION_1_0 ===
template <typename Dispatch>
class UniqueHandleTraits<Instance, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Device, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DeviceMemory, Dispatch>
{
public:
using deleter = ObjectFree<Device, Dispatch>;
};
using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Fence, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Semaphore, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Event, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<QueryPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Buffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<BufferView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Image, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ImageView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ShaderModule, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineCache, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Pipeline, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Sampler, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSet, Dispatch>
{
public:
using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
};
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Framebuffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<RenderPass, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandBuffer, Dispatch>
{
public:
using deleter = PoolFree<Device, CommandPool, Dispatch>;
};
using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_VERSION_1_1 ===
template <typename Dispatch>
class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_VERSION_1_3 ===
template <typename Dispatch>
class UniqueHandleTraits<PrivateDataSlot, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_surface ===
template <typename Dispatch>
class UniqueHandleTraits<SurfaceKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_swapchain ===
template <typename Dispatch>
class UniqueHandleTraits<SwapchainKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_EXT_debug_report ===
template <typename Dispatch>
class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_video_queue ===
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_NVX_binary_import ===
template <typename Dispatch>
class UniqueHandleTraits<CuModuleNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CuFunctionNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_EXT_debug_utils ===
template <typename Dispatch>
class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_acceleration_structure ===
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_EXT_validation_cache ===
template <typename Dispatch>
class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_NV_ray_tracing ===
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_deferred_host_operations ===
template <typename Dispatch>
class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_NV_device_generated_commands ===
template <typename Dispatch>
class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
template <typename Dispatch>
class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_EXT_opacity_micromap ===
template <typename Dispatch>
class UniqueHandleTraits<MicromapEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_NV_optical_flow ===
template <typename Dispatch>
class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//===============
//=== HANDLEs ===
//===============
@ -4402,6 +4841,14 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_create_renderpass2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -4693,6 +5140,18 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_scissor_exclusive ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
@ -7471,274 +7930,6 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Device;
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Buffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# if defined( VK_USE_PLATFORM_FUCHSIA )
template <typename Dispatch>
class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# endif /*VK_USE_PLATFORM_FUCHSIA*/
template <typename Dispatch>
class UniqueHandleTraits<BufferView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandBuffer, Dispatch>
{
public:
using deleter = PoolFree<Device, CommandPool, Dispatch>;
};
using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CuFunctionNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CuModuleNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSet, Dispatch>
{
public:
using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
};
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DeviceMemory, Dispatch>
{
public:
using deleter = ObjectFree<Device, Dispatch>;
};
using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Event, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Fence, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Framebuffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Image, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ImageView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<MicromapEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Pipeline, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineCache, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PrivateDataSlot, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<QueryPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<RenderPass, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Sampler, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Semaphore, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ShaderModule, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SwapchainKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Device
{
public:
@ -12408,16 +12599,6 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch>
class UniqueHandleTraits<Device, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class PhysicalDevice
{
public:
@ -13772,31 +13953,6 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Instance;
template <typename Dispatch>
class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SurfaceKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Instance
{
public:
@ -14462,16 +14618,6 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_VERSION_1_0 ===
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch>
class UniqueHandleTraits<Instance, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,

76
include/vulkan/vulkan_hash.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -5522,6 +5522,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset );
VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
{
@ -6365,6 +6379,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount );
VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT>
{
@ -8122,6 +8152,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
{
@ -8755,6 +8799,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &
physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>
{
@ -9747,6 +9805,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures>
{

2
include/vulkan/vulkan_ios.h
View file

@ -2,7 +2,7 @@
#define VULKAN_IOS_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_macos.h
View file

@ -2,7 +2,7 @@
#define VULKAN_MACOS_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_metal.h
View file

@ -2,7 +2,7 @@
#define VULKAN_METAL_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

55
include/vulkan/vulkan_raii.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -918,7 +918,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
//=== VK_EXT_discard_rectangles ===
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
//=== VK_EXT_display_control ===
vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
@ -1573,7 +1575,8 @@ namespace VULKAN_HPP_NAMESPACE
vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
//=== VK_NV_scissor_exclusive ===
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) );
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
//=== VK_NV_shading_rate_image ===
vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
@ -1856,7 +1859,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0;
//=== VK_EXT_discard_rectangles ===
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0;
//=== VK_EXT_display_control ===
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
@ -2359,7 +2364,8 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
//=== VK_NV_scissor_exclusive ===
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0;
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
//=== VK_NV_shading_rate_image ===
PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
@ -5360,6 +5366,10 @@ namespace VULKAN_HPP_NAMESPACE
void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT;
void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT;
void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_create_renderpass2 ===
void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
@ -5495,6 +5505,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_scissor_exclusive ===
void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const
VULKAN_HPP_NOEXCEPT;
void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT;
@ -14999,6 +15013,24 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
}
VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEnableEXT &&
"Function <vkCmdSetDiscardRectangleEnableEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
getDispatcher()->vkCmdSetDiscardRectangleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( discardRectangleEnable ) );
}
VULKAN_HPP_INLINE void
CommandBuffer::setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleModeEXT &&
"Function <vkCmdSetDiscardRectangleModeEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
getDispatcher()->vkCmdSetDiscardRectangleModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) );
}
//=== VK_EXT_hdr_metadata ===
VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
@ -16575,6 +16607,19 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_scissor_exclusive ===
VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV(
uint32_t firstExclusiveScissor,
VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorEnableNV &&
"Function <vkCmdSetExclusiveScissorEnableNV> needs extension <VK_NV_scissor_exclusive> enabled!" );
getDispatcher()->vkCmdSetExclusiveScissorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
firstExclusiveScissor,
exclusiveScissorEnables.size(),
reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) );
}
VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV(
uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT
{

2
include/vulkan/vulkan_screen.h
View file

@ -2,7 +2,7 @@
#define VULKAN_SCREEN_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

45
include/vulkan/vulkan_static_assertions.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -5906,6 +5906,31 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>::value,
"PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_ARM_shader_core_properties ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM ) == sizeof( VkPhysicalDeviceShaderCorePropertiesARM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>::value,
"PhysicalDeviceShaderCorePropertiesARM is not nothrow_move_constructible!" );
//=== VK_EXT_image_sliced_view_of_3d ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT ) ==
sizeof( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>::value,
"PhysicalDeviceImageSlicedViewOf3DFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT ) == sizeof( VkImageViewSlicedCreateInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT>::value,
"ImageViewSlicedCreateInfoEXT is not nothrow_move_constructible!" );
//=== VK_VALVE_descriptor_set_host_mapping ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ) ==
@ -6379,4 +6404,22 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>::value,
"PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_QCOM_multiview_per_view_render_areas ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) ==
sizeof( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>::value,
"PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) ==
sizeof( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>::value,
"MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" );
#endif

523
include/vulkan/vulkan_structs.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -41469,6 +41469,111 @@ namespace VULKAN_HPP_NAMESPACE
using Type = ImageViewSampleWeightCreateInfoQCOM;
};
struct ImageViewSlicedCreateInfoEXT
{
using NativeType = VkImageViewSlicedCreateInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewSlicedCreateInfoEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR
ImageViewSlicedCreateInfoEXT( uint32_t sliceOffset_ = {}, uint32_t sliceCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, sliceOffset( sliceOffset_ )
, sliceCount( sliceCount_ )
{
}
VULKAN_HPP_CONSTEXPR ImageViewSlicedCreateInfoEXT( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
ImageViewSlicedCreateInfoEXT( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: ImageViewSlicedCreateInfoEXT( *reinterpret_cast<ImageViewSlicedCreateInfoEXT const *>( &rhs ) )
{
}
ImageViewSlicedCreateInfoEXT & operator=( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
ImageViewSlicedCreateInfoEXT & operator=( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceOffset( uint32_t sliceOffset_ ) VULKAN_HPP_NOEXCEPT
{
sliceOffset = sliceOffset_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceCount( uint32_t sliceCount_ ) VULKAN_HPP_NOEXCEPT
{
sliceCount = sliceCount_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkImageViewSlicedCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewSlicedCreateInfoEXT *>( this );
}
operator VkImageViewSlicedCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewSlicedCreateInfoEXT *>( 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 &, uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, sliceOffset, sliceCount );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewSlicedCreateInfoEXT const & ) const = default;
#else
bool operator==( ImageViewSlicedCreateInfoEXT 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 ) && ( sliceOffset == rhs.sliceOffset ) && ( sliceCount == rhs.sliceCount );
# endif
}
bool operator!=( ImageViewSlicedCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewSlicedCreateInfoEXT;
const void * pNext = {};
uint32_t sliceOffset = {};
uint32_t sliceCount = {};
};
template <>
struct CppType<StructureType, StructureType::eImageViewSlicedCreateInfoEXT>
{
using Type = ImageViewSlicedCreateInfoEXT;
};
struct ImageViewUsageCreateInfo
{
using NativeType = VkImageViewUsageCreateInfo;
@ -47811,6 +47916,135 @@ namespace VULKAN_HPP_NAMESPACE
using Type = MultiviewPerViewAttributesInfoNVX;
};
struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM
{
using NativeType = VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( uint32_t perViewRenderAreaCount_ = {},
const VULKAN_HPP_NAMESPACE::Rect2D * pPerViewRenderAreas_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, perViewRenderAreaCount( perViewRenderAreaCount_ )
, pPerViewRenderAreas( pPerViewRenderAreas_ )
{
}
VULKAN_HPP_CONSTEXPR
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( *reinterpret_cast<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & perViewRenderAreas_, const void * pNext_ = nullptr )
: pNext( pNext_ ), perViewRenderAreaCount( static_cast<uint32_t>( perViewRenderAreas_.size() ) ), pPerViewRenderAreas( perViewRenderAreas_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &
operator=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & operator=( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &
setPerViewRenderAreaCount( uint32_t perViewRenderAreaCount_ ) VULKAN_HPP_NOEXCEPT
{
perViewRenderAreaCount = perViewRenderAreaCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &
setPPerViewRenderAreas( const VULKAN_HPP_NAMESPACE::Rect2D * pPerViewRenderAreas_ ) VULKAN_HPP_NOEXCEPT
{
pPerViewRenderAreas = pPerViewRenderAreas_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &
setPerViewRenderAreas( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Rect2D> const & perViewRenderAreas_ ) VULKAN_HPP_NOEXCEPT
{
perViewRenderAreaCount = static_cast<uint32_t>( perViewRenderAreas_.size() );
pPerViewRenderAreas = perViewRenderAreas_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>( this );
}
operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>( 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::Rect2D * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, perViewRenderAreaCount, pPerViewRenderAreas );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & ) const = default;
#else
bool operator==( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM 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 ) && ( perViewRenderAreaCount == rhs.perViewRenderAreaCount ) &&
( pPerViewRenderAreas == rhs.pPerViewRenderAreas );
# endif
}
bool operator!=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
const void * pNext = {};
uint32_t perViewRenderAreaCount = {};
const VULKAN_HPP_NAMESPACE::Rect2D * pPerViewRenderAreas = {};
};
template <>
struct CppType<StructureType, StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>
{
using Type = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
};
struct MutableDescriptorTypeListEXT
{
using NativeType = VkMutableDescriptorTypeListEXT;
@ -60362,6 +60596,104 @@ namespace VULKAN_HPP_NAMESPACE
};
using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT
{
using NativeType = VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 imageSlicedViewOf3D_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, imageSlicedViewOf3D( imageSlicedViewOf3D_ )
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( *reinterpret_cast<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const *>( &rhs ) )
{
}
PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT &
setImageSlicedViewOf3D( VULKAN_HPP_NAMESPACE::Bool32 imageSlicedViewOf3D_ ) VULKAN_HPP_NOEXCEPT
{
imageSlicedViewOf3D = imageSlicedViewOf3D_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>( this );
}
operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>( 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 &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, imageSlicedViewOf3D );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT 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 ) && ( imageSlicedViewOf3D == rhs.imageSlicedViewOf3D );
# endif
}
bool operator!=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 imageSlicedViewOf3D = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT>
{
using Type = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
};
struct PhysicalDeviceImageViewImageFormatInfoEXT
{
using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT;
@ -64198,6 +64530,106 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
};
struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM
{
using NativeType = VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewRenderAreas_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, multiviewPerViewRenderAreas( multiviewPerViewRenderAreas_ )
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( *reinterpret_cast<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const *>( &rhs ) )
{
}
PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM &
operator=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM &
setMultiviewPerViewRenderAreas( VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewRenderAreas_ ) VULKAN_HPP_NOEXCEPT
{
multiviewPerViewRenderAreas = multiviewPerViewRenderAreas_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>( 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 &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, multiviewPerViewRenderAreas );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM 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 ) && ( multiviewPerViewRenderAreas == rhs.multiviewPerViewRenderAreas );
# endif
}
bool operator!=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 multiviewPerViewRenderAreas = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>
{
using Type = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
};
struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
{
using NativeType = VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
@ -71019,6 +71451,95 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceShaderCorePropertiesAMD;
};
struct PhysicalDeviceShaderCorePropertiesARM
{
using NativeType = VkPhysicalDeviceShaderCorePropertiesARM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesARM;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( uint32_t pixelRate_ = {},
uint32_t texelRate_ = {},
uint32_t fmaRate_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, pixelRate( pixelRate_ )
, texelRate( texelRate_ )
, fmaRate( fmaRate_ )
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderCorePropertiesARM( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderCorePropertiesARM( *reinterpret_cast<PhysicalDeviceShaderCorePropertiesARM const *>( &rhs ) )
{
}
PhysicalDeviceShaderCorePropertiesARM & operator=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceShaderCorePropertiesARM & operator=( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceShaderCorePropertiesARM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM *>( this );
}
operator VkPhysicalDeviceShaderCorePropertiesARM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &, uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, pixelRate, texelRate, fmaRate );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderCorePropertiesARM const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderCorePropertiesARM 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 ) && ( pixelRate == rhs.pixelRate ) && ( texelRate == rhs.texelRate ) && ( fmaRate == rhs.fmaRate );
# endif
}
bool operator!=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesARM;
void * pNext = {};
uint32_t pixelRate = {};
uint32_t texelRate = {};
uint32_t fmaRate = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderCorePropertiesARM>
{
using Type = PhysicalDeviceShaderCorePropertiesARM;
};
struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures
{
using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;

10
include/vulkan/vulkan_to_string.hpp
View file

@ -1,4 +1,4 @@
// Copyright 2015-2022 The Khronos Group Inc.
// Copyright 2015-2023 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
@ -4055,6 +4055,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT: return "PhysicalDeviceBorderColorSwizzleFeaturesEXT";
case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT: return "SamplerBorderColorComponentMappingCreateInfoEXT";
case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT: return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
case StructureType::ePhysicalDeviceShaderCorePropertiesARM: return "PhysicalDeviceShaderCorePropertiesARM";
case StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT: return "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT";
case StructureType::eImageViewSlicedCreateInfoEXT: return "ImageViewSlicedCreateInfoEXT";
case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE: return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE";
case StructureType::eDescriptorSetBindingReferenceVALVE: return "DescriptorSetBindingReferenceVALVE";
case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE: return "DescriptorSetLayoutHostMappingInfoVALVE";
@ -4106,6 +4109,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM: return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM";
case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM: return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT: return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM";
case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -5151,10 +5156,13 @@ namespace VULKAN_HPP_NAMESPACE
case DynamicState::ePrimitiveRestartEnable: return "PrimitiveRestartEnable";
case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
case DynamicState::eDiscardRectangleEnableEXT: return "DiscardRectangleEnableEXT";
case DynamicState::eDiscardRectangleModeEXT: return "DiscardRectangleModeEXT";
case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
case DynamicState::eRayTracingPipelineStackSizeKHR: return "RayTracingPipelineStackSizeKHR";
case DynamicState::eViewportShadingRatePaletteNV: return "ViewportShadingRatePaletteNV";
case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
case DynamicState::eExclusiveScissorEnableNV: return "ExclusiveScissorEnableNV";
case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
case DynamicState::eFragmentShadingRateKHR: return "FragmentShadingRateKHR";
case DynamicState::eLineStippleEXT: return "LineStippleEXT";

2
include/vulkan/vulkan_vi.h
View file

@ -2,7 +2,7 @@
#define VULKAN_VI_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_wayland.h
View file

@ -2,7 +2,7 @@
#define VULKAN_WAYLAND_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_win32.h
View file

@ -2,7 +2,7 @@
#define VULKAN_WIN32_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_xcb.h
View file

@ -2,7 +2,7 @@
#define VULKAN_XCB_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_xlib.h
View file

@ -2,7 +2,7 @@
#define VULKAN_XLIB_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
include/vulkan/vulkan_xlib_xrandr.h
View file

@ -2,7 +2,7 @@
#define VULKAN_XLIB_XRANDR_H_ 1
/*
** Copyright 2015-2022 The Khronos Group Inc.
** Copyright 2015-2023 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/

2
registry/apiconventions.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2021-2022 The Khronos Group Inc.
# Copyright 2021-2023 The Khronos Group Inc.
# SPDX-License-Identifier: Apache-2.0
# Generic alias for working group-specific API conventions interface.

4
registry/cgenerator.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
@ -346,6 +346,8 @@ class COutputGenerator(OutputGenerator):
body += self.genOpts.apientry + noneStr(elem.tail)
else:
body += noneStr(elem.text) + noneStr(elem.tail)
if category == 'define' and self.misracppstyle():
body = body.replace("(uint32_t)", "static_cast<uint32_t>")
if body:
# Add extra newline after multi-line entries.
if '\n' in body[0:-1]:

2
registry/generator.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
"""Base class for source/header/doc generators, as well as some utility functions."""

13
registry/genvk.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
@ -9,6 +9,7 @@ import os
import pdb
import re
import sys
import copy
import time
import xml.etree.ElementTree as etree
@ -119,7 +120,7 @@ def makeGenOpts(args):
# The SPDX formatting below works around constraints of the 'reuse' tool
prefixStrings = [
'/*',
'** Copyright 2015-2022 The Khronos Group Inc.',
'** Copyright 2015-2023 The Khronos Group Inc.',
'**',
'** SPDX-License-Identifier' + ': Apache-2.0',
'*/',
@ -141,7 +142,10 @@ def makeGenOpts(args):
# An API style conventions object
conventions = APIConventions()
defaultAPIName = conventions.xml_api_name
if args.apiname is not None:
defaultAPIName = args.apiname
else:
defaultAPIName = conventions.xml_api_name
# API include files for spec and ref pages
# Overwrites include subdirectories in spec source tree
@ -699,6 +703,9 @@ def genTarget(args):
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-apiname', action='store',
default=None,
help='Specify API to generate (defaults to repository-specific conventions object value)')
parser.add_argument('-defaultExtensions', action='store',
default=APIConventions().xml_api_name,
help='Specify a single class of extensions to add to targets')

315
registry/parse_dependency.py Executable file
View file

@ -0,0 +1,315 @@
#!/usr/bin/python3
# Copyright 2022-2023 The Khronos Group Inc.
# Copyright 2003-2019 Paul McGuire
# SPDX-License-Identifier: MIT
# apirequirements.py - parse 'depends' expressions in API XML
# Supported methods:
# dependency - the expression string
#
# evaluateDependency(dependency, isSupported) evaluates the expression,
# returning a boolean result. isSupported takes an extension or version name
# string and returns a boolean.
#
# dependencyLanguage(dependency) returns an English string equivalent
# to the expression, suitable for header file comments.
#
# dependencyNames(dependency) returns a set of the extension and
# version names in the expression.
#
# dependencyMarkup(dependency) returns a string containing asciidoctor
# markup for English equivalent to the expression, suitable for extension
# appendices.
#
# All may throw a ParseException if the expression cannot be parsed or is
# not completely consumed by parsing.
# Supported expressions at present:
# - extension names
# - '+' as AND connector
# - ',' as OR connector
# - parenthesization for grouping
# Based on https://github.com/pyparsing/pyparsing/blob/master/examples/fourFn.py
from pyparsing import (
Literal,
Word,
Group,
Forward,
alphas,
alphanums,
Regex,
ParseException,
CaselessKeyword,
Suppress,
delimitedList,
infixNotation,
)
import math
import operator
import pyparsing as pp
import re
def nameMarkup(name):
"""Returns asciidoc markup to generate a link to an API version or
extension anchor.
- name - version or extension name"""
# Could use ApiConventions.is_api_version_name, but that does not split
# out the major/minor version numbers.
match = re.search("[A-Z]+_VERSION_([0-9]+)_([0-9]+)", name)
if match is not None:
major = match.group(1)
minor = match.group(2)
version = major + '.' + minor
return f'<<versions-{major}.{minor}, Version {version}>>'
else:
return 'apiext:' + name
exprStack = []
def push_first(toks):
"""Push a token on the global stack
- toks - first element is the token to push"""
exprStack.append(toks[0])
# An identifier (version or extension name)
dependencyIdent = Word(alphanums + '_')
# Infix expression for depends expressions
dependencyExpr = pp.infixNotation(dependencyIdent,
[ (pp.oneOf(', +'), 2, pp.opAssoc.LEFT), ])
# BNF grammar for depends expressions
_bnf = None
def dependencyBNF():
"""
boolop :: '+' | ','
extname :: Char(alphas)
atom :: extname | '(' expr ')'
expr :: atom [ boolop atom ]*
"""
global _bnf
if _bnf is None:
and_, or_ = map(Literal, '+,')
lpar, rpar = map(Suppress, '()')
boolop = and_ | or_
expr = Forward()
expr_list = delimitedList(Group(expr))
atom = (
boolop[...]
+ (
(dependencyIdent).setParseAction(push_first)
| Group(lpar + expr + rpar)
)
)
expr <<= atom + (boolop + atom).setParseAction(push_first)[...]
_bnf = expr
return _bnf
# map operator symbols to corresponding arithmetic operations
_opn = {
'+': operator.and_,
',': operator.or_,
}
# map operator symbols to corresponding words
_opname = {
'+': 'and',
',': 'or',
}
def evaluateStack(stack, isSupported):
"""Evaluate an expression stack, returning a boolean result.
- stack - the stack
- isSupported - function taking a version or extension name string and
returning True or False if that name is supported or not."""
op, num_args = stack.pop(), 0
if isinstance(op, tuple):
op, num_args = op
if op in '+,':
# Note: operands are pushed onto the stack in reverse order
op2 = evaluateStack(stack, isSupported)
op1 = evaluateStack(stack, isSupported)
return _opn[op](op1, op2)
elif op[0].isalpha():
return isSupported(op)
else:
raise Exception(f'invalid op: {op}')
def evaluateDependency(dependency, isSupported):
"""Evaluate a dependency expression, returning a boolean result.
- dependency - the expression
- isSupported - function taking a version or extension name string and
returning True or False if that name is supported or not."""
global exprStack
exprStack = []
results = dependencyBNF().parseString(dependency, parseAll=True)
val = evaluateStack(exprStack[:], isSupported)
return val
def evalDependencyLanguage(stack, specmacros):
"""Evaluate an expression stack, returning an English equivalent
- stack - the stack
- specmacros - if True, prepare the language for spec inclusion"""
op, num_args = stack.pop(), 0
if isinstance(op, tuple):
op, num_args = op
if op in '+,':
# Could parenthesize, not needed yet
rhs = evalDependencyLanguage(stack, specmacros)
return evalDependencyLanguage(stack, specmacros) + f' {_opname[op]} ' + rhs
elif op[0].isalpha():
# This is an extension or feature name
if specmacros:
return nameMarkup(op)
else:
return op
else:
raise Exception(f'invalid op: {op}')
def dependencyLanguage(dependency, specmacros = False):
"""Return an API dependency expression translated to a form suitable for
asciidoctor conditionals or header file comments.
- dependency - the expression
- specmacros - if False, return a string that can be used as an
asciidoctor conditional.
If True, return a string suitable for spec inclusion with macros and
xrefs included."""
global exprStack
exprStack = []
results = dependencyBNF().parseString(dependency, parseAll=True)
return evalDependencyLanguage(exprStack, specmacros)
def evalDependencyNames(stack):
"""Evaluate an expression stack, returning the set of extension and
feature names used in the expression.
- stack - the stack"""
op, num_args = stack.pop(), 0
if isinstance(op, tuple):
op, num_args = op
if op in '+,':
# Do not evaluate the operation. We only care about the names.
return evalDependencyNames(stack) | evalDependencyNames(stack)
elif op[0].isalpha():
return { op }
else:
raise Exception(f'invalid op: {op}')
def dependencyNames(dependency):
"""Return a set of the extension and version names in an API dependency
expression. Used when determining transitive dependencies for spec
generation with specific extensions included.
- dependency - the expression"""
global exprStack
exprStack = []
results = dependencyBNF().parseString(dependency, parseAll=True)
# print(f'names(): stack = {exprStack}')
return evalDependencyNames(exprStack)
def markupTraverse(expr, level = 0, root = True):
"""Recursively process a dependency in infix form, transforming it into
asciidoctor markup with expression nesting indicated by indentation
level.
- expr - expression to process
- level - indentation level to render expression at
- root - True only on initial call"""
if level > 0:
prefix = '{nbsp}{nbsp}' * level * 2 + ' '
else:
prefix = ''
str = ''
for elem in expr:
if isinstance(elem, pp.ParseResults):
if not root:
nextlevel = level + 1
else:
# Do not indent the outer expression
nextlevel = level
str = str + markupTraverse(elem, level = nextlevel, root = False)
elif elem in ('+', ','):
str = str + f'{prefix}{_opname[elem]} +\n'
else:
str = str + f'{prefix}{nameMarkup(elem)} +\n'
return str
def dependencyMarkup(dependency):
"""Return asciidoctor markup for a human-readable equivalent of an API
dependency expression, suitable for use in extension appendix
metadata.
- dependency - the expression"""
parsed = dependencyExpr.parseString(dependency)
return markupTraverse(parsed)
if __name__ == "__main__":
termdict = {
'VK_VERSION_1_1' : True,
'f' : False,
't' : True,
'false' : False,
'true' : True,
}
termSupported = lambda name: name in termdict and termdict[name]
for dependency in [
't',
#'t+t+f',
#'t+(t+f),(f,t))',
#'t+((t+f),(f,t)))',
'VK_VERSION_1_1+(t,f)',
]:
print(f'expr = {dependency}\n{dependencyMarkup(dependency)}')
print(f' language = {dependencyLanguage(dependency)}')
print(f' names = {dependencyNames(dependency)}')
print(f' value = {evaluateDependency(dependency, termSupported)}')
def test(dependency, expected):
val = False
try:
val = evaluateDependency(dependency, termSupported)
except ParseException as pe:
print(dependency, f'failed parse: {dependency}')
except Exception as e:
print(dependency, f'failed eval: {dependency}')
if val == expected:
print(f'{dependency} = {val} (as expected)')
else:
print(f'{dependency} ERROR: {val} != {expected}')
test('VK_VERSION_1_1+(false,true)', True)
test('true', True)
test('(true)', True)
test('false,false', False)
test('false,true', True)
test('false+true', False)
test('true+true', True)

49
registry/reg.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
@ -658,24 +658,6 @@ class Registry:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
# Construct a "validextensionstructs" list for parent structures
# based on "structextends" tags in child structures
disabled_types = []
for disabled_ext in self.reg.findall('extensions/extension[@supported="disabled"]'):
for type_elem in disabled_ext.findall("*/type"):
disabled_types.append(type_elem.get('name'))
for type_elem in self.reg.findall('types/type'):
if type_elem.get('name') not in disabled_types:
# The structure type this may be chained to.
struct_extends = type_elem.get('structextends')
if struct_extends is not None:
for parent in struct_extends.split(','):
# self.gen.logMsg('diag', type.get('name'), 'extends', parent)
self.validextensionstructs[parent].append(type_elem.get('name'))
# Sort the lists so they do not depend on the XML order
for parent in self.validextensionstructs:
self.validextensionstructs[parent].sort()
# Parse out all spirv tags in dictionaries
# Use addElementInfo to catch duplicates
for spirv in self.reg.findall('spirvextensions/spirvextension'):
@ -1002,10 +984,8 @@ class Registry:
# expression of extension names.
# 'required_key' is used only as a dictionary key at
# present, and passed through to the script generators, so
# they must be prepared to parse that expression.
required_key = require.get('feature')
if required_key is None:
required_key = require.get('extension')
# they must be prepared to parse that boolean expression.
required_key = require.get('depends')
# Loop over types, enums, and commands in the tag
for typeElem in require.findall('type'):
@ -1330,7 +1310,7 @@ class Registry:
stripped = False
for api in attribstring.split(','):
##print('Checking API {} referenced by {}'.format(api, key))
if supportedDictionary[api].required:
if api in supportedDictionary and supportedDictionary[api].required:
apis.append(api)
else:
stripped = True
@ -1354,6 +1334,24 @@ class Registry:
genProc = self.gen.genFormat
genProc(format, name, alias)
def tagValidExtensionStructs(self):
"""Construct a "validextensionstructs" list for parent structures
based on "structextends" tags in child structures.
Only do this for structures tagged as required."""
for typeinfo in self.typedict.values():
type_elem = typeinfo.elem
if typeinfo.required and type_elem.get('category') == 'struct':
struct_extends = type_elem.get('structextends')
if struct_extends is not None:
for parent in struct_extends.split(','):
# self.gen.logMsg('diag', type_elem.get('name'), 'extends', parent)
self.validextensionstructs[parent].append(type_elem.get('name'))
# Sort the lists so they do not depend on the XML order
for parent in self.validextensionstructs:
self.validextensionstructs[parent].sort()
def apiGen(self):
"""Generate interface for specified versions using the current
generator and generator options"""
@ -1525,6 +1523,9 @@ class Registry:
self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
# Construct lists of valid extension structures
self.tagValidExtensionStructs()
# @@May need to strip <spirvcapability> / <spirvextension> <enable>
# tags of these forms:
# <enable version="VK_API_VERSION_1_0"/>

11
registry/spec_tools/conventions.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
@ -34,6 +34,11 @@ TYPES_KNOWN_ALWAYS_VALID = set(('char',
# Split an extension name into vendor ID and name portions
EXT_NAME_DECOMPOSE_RE = re.compile(r'[A-Z]+_(?P<vendor>[A-Z]+)_(?P<name>[\w_]+)')
# Match an API version name.
# This could be refined further for specific APIs.
API_VERSION_NAME_RE = re.compile(r'[A-Z]+_VERSION_[0-9]')
class ProseListFormats(Enum):
"""A connective, possibly with a quantifier."""
AND = 0
@ -443,3 +448,7 @@ class ConventionsBase(abc.ABC):
reference pages."""
return ''
def is_api_version_name(self, name):
"""Return True if name is an API version name."""
return API_VERSION_NAME_RE.match(name) is not None

2
registry/spec_tools/util.py
View file

@ -1,6 +1,6 @@
"""Utility functions not closely tied to other spec_tools types."""
# Copyright (c) 2018-2019 Collabora, Ltd.
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0

734
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

2
registry/video.xml
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<registry>
<comment>
Copyright 2021-2022 The Khronos Group Inc.
Copyright 2021-2023 The Khronos Group Inc.
SPDX-License-Identifier: Apache-2.0 OR MIT
</comment>

1648
registry/vk.xml
View file

File diff suppressed because it is too large Load diff

4
registry/vkconventions.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
# Copyright 2013-2023 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
@ -109,6 +109,8 @@ class VulkanConventions(ConventionsBase):
[ r'_H_(26[45])_', r'_H\1_' ],
[ r'_VULKAN_([0-9])([0-9])_', r'_VULKAN_\1_\2_' ],
[ r'_DIRECT_FB_', r'_DIRECTFB_' ],
[ r'_VULKAN_SC_10', r'_VULKAN_SC_1_0' ],
]
for subpat in subpats: