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.294
Some checks failed
ci / cmake-unix (3.15, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (3.15, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-windows (3.15) (push) Has been cancelled
Details
ci / cmake-windows (latest) (push) Has been cancelled
Details
ci / windows_clang (clang) (push) Has been cancelled
Details
ci / windows_clang (clang-cl) (push) Has been cancelled
Details
ci / reuse (push) Has been cancelled
Details

Browse source
This commit is contained in:
Jon Leech 2024-08-23 04:01:02 -07:00 committed by Jon Leech
parent d205aff40b
commit a6a5dc0d07
15 changed files with 4101 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
include/vulkan/vulkan.cppm
View file

@ -941,6 +941,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError;
using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
using VULKAN_HPP_NAMESPACE::NotEnoughSpaceKHRError;
#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
using VULKAN_HPP_NAMESPACE::ResultValue;
@ -2399,6 +2400,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderObjectExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderObjectSpecVersion;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::KHRPipelineBinaryExtensionName;
using VULKAN_HPP_NAMESPACE::KHRPipelineBinarySpecVersion;
//=== VK_QCOM_tile_properties ===
using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesSpecVersion;
@ -4256,6 +4261,20 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT;
using VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR;
using VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR;
using VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR;
//=== VK_QCOM_tile_properties ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM;
@ -4544,6 +4563,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::ShaderEXT;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
//======================
//=== UNIQUE HANDLEs ===
//======================
@ -4641,8 +4663,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV;
//=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//======================
@ -4745,8 +4770,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
//=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
using VULKAN_HPP_NAMESPACE::SharedShaderEXT;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//===========================
@ -4927,6 +4955,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_RAII_NAMESPACE::ShaderEXT;
using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR;
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs;
} // namespace VULKAN_HPP_RAII_NAMESPACE
#endif
} // namespace VULKAN_HPP_NAMESPACE

183
include/vulkan/vulkan.hpp
View file

@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 293, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 294, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -5751,6 +5751,44 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders );
}
//=== VK_KHR_pipeline_binary ===
VkResult vkCreatePipelineBinariesKHR( VkDevice device,
const VkPipelineBinaryCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkPipelineBinaryHandlesInfoKHR * pBinaries ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries );
}
void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator );
}
VkResult vkGetPipelineKeyKHR( VkDevice device,
const VkPipelineCreateInfoKHR * pPipelineCreateInfo,
VkPipelineBinaryKeyKHR * pPipelineKey ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey );
}
VkResult vkGetPipelineBinaryDataKHR( VkDevice device,
const VkPipelineBinaryDataInfoKHR * pInfo,
VkPipelineBinaryKeyKHR * pPipelineBinaryKey,
size_t * pPipelineBinaryDataSize,
void * pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData );
}
VkResult vkReleaseCapturedPipelineDataKHR( VkDevice device,
const VkReleaseCapturedPipelineDataInfoKHR * pInfo,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator );
}
//=== VK_QCOM_tile_properties ===
VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device,
@ -6528,6 +6566,14 @@ namespace VULKAN_HPP_NAMESPACE
CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
};
class NotEnoughSpaceKHRError : public SystemError
{
public:
NotEnoughSpaceKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {}
NotEnoughSpaceKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {}
};
namespace detail
{
[[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
@ -6570,6 +6616,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message );
case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
case Result::eErrorNotEnoughSpaceKHR: throw NotEnoughSpaceKHRError( message );
default: throw SystemError( make_error_code( result ), message );
}
}
@ -8357,6 +8404,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION;
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinaryExtensionName = VK_KHR_PIPELINE_BINARY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinarySpecVersion = VK_KHR_PIPELINE_BINARY_SPEC_VERSION;
//=== VK_QCOM_tile_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION;
@ -8550,6 +8601,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<ComputePipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<GraphicsPipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR>
{
@ -11265,6 +11334,15 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<ExecutionGraphPipelineCreateInfoAMDX, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineShaderStageNodeCreateInfoAMDX, PipelineShaderStageCreateInfo>
{
@ -11406,6 +11484,15 @@ namespace VULKAN_HPP_NAMESPACE
};
//=== VK_KHR_ray_tracing_pipeline ===
template <>
struct StructExtends<RayTracingPipelineCreateInfoKHR, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>
{
@ -11632,6 +11719,15 @@ namespace VULKAN_HPP_NAMESPACE
};
//=== VK_NV_ray_tracing ===
template <>
struct StructExtends<RayTracingPipelineCreateInfoNV, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>
{
@ -15640,6 +15736,70 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_pipeline_binary ===
template <>
struct StructExtends<PhysicalDevicePipelineBinaryFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineBinaryFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineBinaryPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DevicePipelineBinaryInternalCacheControlKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineBinaryInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineBinaryInfoKHR, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineBinaryInfoKHR, RayTracingPipelineCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_QCOM_tile_properties ===
template <>
struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2>
@ -17920,6 +18080,13 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0;
//=== VK_KHR_pipeline_binary ===
PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0;
PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0;
PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0;
PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0;
PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0;
//=== VK_QCOM_tile_properties ===
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
@ -19325,6 +19492,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) );
//=== VK_KHR_pipeline_binary ===
vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetInstanceProcAddr( instance, "vkCreatePipelineBinariesKHR" ) );
vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetInstanceProcAddr( instance, "vkDestroyPipelineBinaryKHR" ) );
vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineKeyKHR" ) );
vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineBinaryDataKHR" ) );
vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetInstanceProcAddr( instance, "vkReleaseCapturedPipelineDataKHR" ) );
//=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM =
@ -20378,6 +20552,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) );
//=== VK_KHR_pipeline_binary ===
vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) );
vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) );
vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) );
vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) );
vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) );
//=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM =

138
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 293
#define VK_HEADER_VERSION 294
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@ -189,6 +189,8 @@ typedef enum VkResult {
VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000,
VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000,
VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
VK_PIPELINE_BINARY_MISSING_KHR = 1000483000,
VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
@ -1043,6 +1045,16 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001,
VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR = 1000483000,
VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR = 1000483001,
VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR = 1000483002,
VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR = 1000483003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR = 1000483004,
VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR = 1000483005,
VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR = 1000483006,
VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR = 1000483007,
VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR = 1000483008,
VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR = 1000483009,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000,
VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000,
@ -1421,6 +1433,7 @@ typedef enum VkObjectType {
VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000,
VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000,
VK_OBJECT_TYPE_SHADER_EXT = 1000482000,
VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000,
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT,
@ -11184,6 +11197,7 @@ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCE
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL;
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL;
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL;
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL;
typedef VkFlags64 VkBufferUsageFlags2KHR;
@ -11318,6 +11332,128 @@ typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
// VK_KHR_pipeline_binary is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_pipeline_binary 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineBinaryKHR)
#define VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR 32U
#define VK_KHR_PIPELINE_BINARY_SPEC_VERSION 1
#define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary"
typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 pipelineBinaries;
} VkPhysicalDevicePipelineBinaryFeaturesKHR;
typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR {
VkStructureType sType;
void* pNext;
VkBool32 pipelineBinaryInternalCache;
VkBool32 pipelineBinaryInternalCacheControl;
VkBool32 pipelineBinaryPrefersInternalCache;
VkBool32 pipelineBinaryPrecompiledInternalCache;
VkBool32 pipelineBinaryCompressedData;
} VkPhysicalDevicePipelineBinaryPropertiesKHR;
typedef struct VkDevicePipelineBinaryInternalCacheControlKHR {
VkStructureType sType;
const void* pNext;
VkBool32 disableInternalCache;
} VkDevicePipelineBinaryInternalCacheControlKHR;
typedef struct VkPipelineBinaryKeyKHR {
VkStructureType sType;
void* pNext;
uint32_t keySize;
uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR];
} VkPipelineBinaryKeyKHR;
typedef struct VkPipelineBinaryDataKHR {
size_t dataSize;
void* pData;
} VkPipelineBinaryDataKHR;
typedef struct VkPipelineBinaryKeysAndDataKHR {
uint32_t binaryCount;
const VkPipelineBinaryKeyKHR* pPipelineBinaryKeys;
const VkPipelineBinaryDataKHR* pPipelineBinaryData;
} VkPipelineBinaryKeysAndDataKHR;
typedef struct VkPipelineCreateInfoKHR {
VkStructureType sType;
void* pNext;
} VkPipelineCreateInfoKHR;
typedef struct VkPipelineBinaryCreateInfoKHR {
VkStructureType sType;
const void* pNext;
const VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo;
VkPipeline pipeline;
const VkPipelineCreateInfoKHR* pPipelineCreateInfo;
} VkPipelineBinaryCreateInfoKHR;
typedef struct VkPipelineBinaryInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t binaryCount;
const VkPipelineBinaryKHR* pPipelineBinaries;
} VkPipelineBinaryInfoKHR;
typedef struct VkReleaseCapturedPipelineDataInfoKHR {
VkStructureType sType;
void* pNext;
VkPipeline pipeline;
} VkReleaseCapturedPipelineDataInfoKHR;
typedef struct VkPipelineBinaryDataInfoKHR {
VkStructureType sType;
void* pNext;
VkPipelineBinaryKHR pipelineBinary;
} VkPipelineBinaryDataInfoKHR;
typedef struct VkPipelineBinaryHandlesInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t pipelineBinaryCount;
VkPipelineBinaryKHR* pPipelineBinaries;
} VkPipelineBinaryHandlesInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineBinariesKHR)(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries);
typedef void (VKAPI_PTR *PFN_vkDestroyPipelineBinaryKHR)(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineKeyKHR)(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey);
typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineBinaryDataKHR)(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData);
typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(
VkDevice device,
const VkPipelineBinaryCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineBinaryHandlesInfoKHR* pBinaries);
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR(
VkDevice device,
VkPipelineBinaryKHR pipelineBinary,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR(
VkDevice device,
const VkPipelineCreateInfoKHR* pPipelineCreateInfo,
VkPipelineBinaryKeyKHR* pPipelineKey);
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(
VkDevice device,
const VkPipelineBinaryDataInfoKHR* pInfo,
VkPipelineBinaryKeyKHR* pPipelineBinaryKey,
size_t* pPipelineBinaryDataSize,
void* pPipelineBinaryData);
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(
VkDevice device,
const VkReleaseCapturedPipelineDataInfoKHR* pInfo,
const VkAllocationCallbacks* pAllocator);
#endif
// VK_KHR_cooperative_matrix is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_cooperative_matrix 1
#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2

29
include/vulkan/vulkan_enums.hpp
View file

@ -284,7 +284,9 @@ namespace VULKAN_HPP_NAMESPACE
eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR,
eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT,
eIncompatibleShaderBinaryEXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT
eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT,
ePipelineBinaryMissingKHR = VK_PIPELINE_BINARY_MISSING_KHR,
eErrorNotEnoughSpaceKHR = VK_ERROR_NOT_ENOUGH_SPACE_KHR
};
enum class StructureType
@ -1336,6 +1338,16 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT,
eShaderCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
ePhysicalDevicePipelineBinaryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR,
ePipelineBinaryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR,
ePipelineBinaryInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR,
ePipelineBinaryKeyKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR,
ePhysicalDevicePipelineBinaryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR,
eReleaseCapturedPipelineDataInfoKHR = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR,
ePipelineBinaryDataInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR,
ePipelineCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR,
eDevicePipelineBinaryInternalCacheControlKHR = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR,
ePipelineBinaryHandlesInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR,
ePhysicalDeviceTilePropertiesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM,
eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM,
ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC,
@ -1503,7 +1515,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_FUCHSIA*/
eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT,
eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV,
eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT
eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT,
ePipelineBinaryKHR = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR
};
enum class VendorId
@ -7014,7 +7027,8 @@ namespace VULKAN_HPP_NAMESPACE
eNoProtectedAccessEXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT,
eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT,
eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV,
eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT
eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT,
eCaptureData = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR
};
using PipelineCreateFlags2KHR = Flags<PipelineCreateFlagBits2KHR>;
@ -7038,7 +7052,8 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCreateFlagBits2KHR::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2KHR::eRayTracingOpacityMicromapEXT |
PipelineCreateFlagBits2KHR::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2KHR::eDepthStencilAttachmentFeedbackLoopEXT |
PipelineCreateFlagBits2KHR::eNoProtectedAccessEXT | PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT |
PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2KHR::eDescriptorBufferEXT;
PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2KHR::eDescriptorBufferEXT |
PipelineCreateFlagBits2KHR::eCaptureData;
};
enum class BufferUsageFlagBits2KHR : VkBufferUsageFlags2KHR
@ -7463,7 +7478,11 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
//=== VK_EXT_shader_object ===
case VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
case VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT:
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
//=== VK_KHR_pipeline_binary ===
case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
default: VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
}

29
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -403,6 +403,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_AMD_anti_lag",
"VK_KHR_ray_tracing_position_fetch",
"VK_EXT_shader_object",
"VK_KHR_pipeline_binary",
"VK_QCOM_tile_properties",
"VK_SEC_amigo_profiling",
"VK_QCOM_multiview_per_view_viewports",
@ -2153,6 +2154,11 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_dynamic_rendering",
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_pipeline_binary",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance5",
} } } } },
{ "VK_QCOM_tile_properties",
{ { "VK_VERSION_1_0",
{ {
@ -3078,17 +3084,18 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_ANDROID_external_format_resolve" )
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_SEC_amigo_profiling" ) ||
( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) ||
( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_video_decode_av1" ) ||
( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" )
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) ||
( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) ||
( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_shader_float_controls2" )
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/

463
include/vulkan/vulkan_funcs.hpp
View file

@ -25732,6 +25732,469 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_pipeline_binary ===
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR * pBinaries,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkCreatePipelineBinariesKHR( m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( pCreateInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( pBinaries ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineBinaryKHRAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
Device::createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator> pipelineBinaries;
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries;
VULKAN_HPP_NAMESPACE::Result result;
if ( createInfo.pKeysAndDataInfo )
{
VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
else
{
VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaries.resize( binaries.pipelineBinaryCount );
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
}
VULKAN_HPP_NAMESPACE::detail::resultCheck(
result,
VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete, VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>( result, std::move( pipelineBinaries ) );
}
template <typename PipelineBinaryKHRAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
Device::createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator> pipelineBinaries( pipelineBinaryKHRAllocator );
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries;
VULKAN_HPP_NAMESPACE::Result result;
if ( createInfo.pKeysAndDataInfo )
{
VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
else
{
VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaries.resize( binaries.pipelineBinaryCount );
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
}
VULKAN_HPP_NAMESPACE::detail::resultCheck(
result,
VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete, VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>( result, std::move( pipelineBinaries ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch, typename PipelineBinaryKHRAllocator>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
Device::createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> pipelineBinaries;
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries;
VULKAN_HPP_NAMESPACE::Result result;
if ( createInfo.pKeysAndDataInfo )
{
VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
else
{
VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaries.resize( binaries.pipelineBinaryCount );
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
}
VULKAN_HPP_NAMESPACE::detail::resultCheck(
result,
VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete, VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries;
uniquePipelineBinaries.reserve( pipelineBinaries.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipelineBinary : pipelineBinaries )
{
uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>(
result, std::move( uniquePipelineBinaries ) );
}
template <typename Dispatch,
typename PipelineBinaryKHRAllocator,
typename std::enable_if<
std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>::value,
int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
Device::createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function <vkCreatePipelineBinariesKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> pipelineBinaries;
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries;
VULKAN_HPP_NAMESPACE::Result result;
if ( createInfo.pKeysAndDataInfo )
{
VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
else
{
VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaries.resize( binaries.pipelineBinaryCount );
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreatePipelineBinariesKHR(
m_device,
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
}
VULKAN_HPP_NAMESPACE::detail::resultCheck(
result,
VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete, VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries(
pipelineBinaryKHRAllocator );
uniquePipelineBinaries.reserve( pipelineBinaries.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipelineBinary : pipelineBinaries )
{
uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>(
result, std::move( uniquePipelineBinaries ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkDestroyPipelineBinaryKHR( m_device, static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function <vkDestroyPipelineBinaryKHR> requires <VK_KHR_pipeline_binary>" );
# endif
d.vkDestroyPipelineBinaryKHR(
m_device,
static_cast<VkPipelineBinaryKHR>( pipelineBinary ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkDestroyPipelineBinaryKHR( m_device, static_cast<VkPipelineBinaryKHR>( pipelineBinary ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function <vkDestroyPipelineBinaryKHR> requires <VK_KHR_pipeline_binary>" );
# endif
d.vkDestroyPipelineBinaryKHR(
m_device,
static_cast<VkPipelineBinaryKHR>( pipelineBinary ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineKeyKHR( const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR * pPipelineCreateInfo,
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineKey,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetPipelineKeyKHR(
m_device, reinterpret_cast<const VkPipelineCreateInfoKHR *>( pPipelineCreateInfo ), reinterpret_cast<VkPipelineBinaryKeyKHR *>( pPipelineKey ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::type
Device::getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetPipelineKeyKHR && "Function <vkGetPipelineKeyKHR> requires <VK_KHR_pipeline_binary>" );
# endif
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR pipelineKey;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineKeyKHR(
m_device,
reinterpret_cast<const VkPipelineCreateInfoKHR *>( static_cast<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR *>( pipelineCreateInfo ) ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineKey ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineKey ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR * pInfo,
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineBinaryKey,
size_t * pPipelineBinaryDataSize,
void * pPipelineBinaryData,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetPipelineBinaryDataKHR( m_device,
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( pInfo ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( pPipelineBinaryKey ),
pPipelineBinaryDataSize,
pPipelineBinaryData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint8_tAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
Device::getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>> data_;
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first;
std::vector<uint8_t, Uint8_tAllocator> & pipelineBinaryData = data_.second;
size_t pipelineBinaryDataSize;
VULKAN_HPP_NAMESPACE::Result result =
static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineBinaryDataKHR( m_device,
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
nullptr ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaryData.resize( pipelineBinaryDataSize );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineBinaryDataKHR( m_device,
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
reinterpret_cast<void *>( pipelineBinaryData.data() ) ) );
}
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
}
template <typename Uint8_tAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
Device::getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info,
Uint8_tAllocator & uint8_tAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" );
# endif
std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>> data_(
std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) );
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first;
std::vector<uint8_t, Uint8_tAllocator> & pipelineBinaryData = data_.second;
size_t pipelineBinaryDataSize;
VULKAN_HPP_NAMESPACE::Result result =
static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineBinaryDataKHR( m_device,
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
nullptr ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaryData.resize( pipelineBinaryDataSize );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkGetPipelineBinaryDataKHR( m_device,
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
reinterpret_cast<void *>( pipelineBinaryData.data() ) ) );
}
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR * pInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkReleaseCapturedPipelineDataKHR(
m_device, reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( pInfo ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" );
# endif
d.vkReleaseCapturedPipelineDataKHR(
m_device,
reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_QCOM_tile_properties ===
template <typename Dispatch>

238
include/vulkan/vulkan_handles.hpp
View file

@ -1676,6 +1676,20 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceShaderObjectPropertiesEXT;
struct ShaderCreateInfoEXT;
//=== VK_KHR_pipeline_binary ===
struct PhysicalDevicePipelineBinaryFeaturesKHR;
struct PhysicalDevicePipelineBinaryPropertiesKHR;
struct DevicePipelineBinaryInternalCacheControlKHR;
struct PipelineBinaryKeyKHR;
struct PipelineBinaryDataKHR;
struct PipelineBinaryKeysAndDataKHR;
struct PipelineBinaryCreateInfoKHR;
struct PipelineBinaryInfoKHR;
struct ReleaseCapturedPipelineDataInfoKHR;
struct PipelineBinaryDataInfoKHR;
struct PipelineCreateInfoKHR;
struct PipelineBinaryHandlesInfoKHR;
//=== VK_QCOM_tile_properties ===
struct PhysicalDeviceTilePropertiesFeaturesQCOM;
struct TilePropertiesQCOM;
@ -1962,6 +1976,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object ===
class ShaderEXT;
//=== VK_KHR_pipeline_binary ===
class PipelineBinaryKHR;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
//======================
//=== UNIQUE HANDLEs ===
@ -2417,6 +2434,16 @@ namespace VULKAN_HPP_NAMESPACE
};
using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_pipeline_binary ===
template <typename Dispatch>
class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//===============
@ -9714,6 +9741,110 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class PipelineBinaryKHR
{
public:
using CType = VkPipelineBinaryKHR;
using NativeType = VkPipelineBinaryKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default;
PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default;
PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default;
#else
PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} ) ) {}
PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipelineBinaryKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {}
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT
{
m_pipelineBinaryKHR = pipelineBinaryKHR;
return *this;
}
#endif
PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_pipelineBinaryKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineBinaryKHR const & ) const = default;
#else
bool operator==( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR == rhs.m_pipelineBinaryKHR;
}
bool operator!=( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR != rhs.m_pipelineBinaryKHR;
}
bool operator<( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR < rhs.m_pipelineBinaryKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinaryKHR == VK_NULL_HANDLE;
}
private:
VkPipelineBinaryKHR m_pipelineBinaryKHR = {};
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
};
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
template <>
struct CppType<VkPipelineBinaryKHR, VK_NULL_HANDLE>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
};
#endif
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Queue
{
public:
@ -14987,6 +15118,113 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_pipeline_binary ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR * pBinaries,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>,
typename std::enable_if<
std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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 destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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 destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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 destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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>
VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR * pPipelineCreateInfo,
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineKey,
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>
VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::type
getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR * pInfo,
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineBinaryKey,
size_t * pPipelineBinaryDataSize,
void * pPipelineBinaryData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info,
Uint8_tAllocator & uint8_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR * pInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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 releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_QCOM_tile_properties ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

180
include/vulkan/vulkan_hash.hpp
View file

@ -525,6 +525,17 @@ namespace std
}
};
//=== VK_KHR_pipeline_binary ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkPipelineBinaryKHR>{}( static_cast<VkPipelineBinaryKHR>( pipelineBinaryKHR ) );
}
};
#if 14 <= VULKAN_HPP_CPP_VERSION
//======================================
//=== HASH structures for structures ===
@ -4019,6 +4030,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR const & devicePipelineBinaryInternalCacheControlKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.disableInternalCache );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo>
{
@ -10514,6 +10539,38 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR const & physicalDevicePipelineBinaryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pipelineBinaries );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR const & physicalDevicePipelineBinaryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCache );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCacheControl );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrefersInternalCache );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrecompiledInternalCache );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryCompressedData );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures>
{
@ -12713,6 +12770,116 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR const & pipelineBinaryKeyKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.keySize );
for ( size_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.key[i] );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR const & pipelineBinaryDataKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.dataSize );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.pData );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR const & pipelineBinaryKeysAndDataKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.binaryCount );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryData );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR const & pipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.pNext );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & pipelineBinaryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pKeysAndDataInfo );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pipeline );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pPipelineCreateInfo );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR const & pipelineBinaryDataInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pipelineBinary );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR const & pipelineBinaryHandlesInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pipelineBinaryCount );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pPipelineBinaries );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR const & pipelineBinaryInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.binaryCount );
VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pPipelineBinaries );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
{
@ -13927,6 +14094,19 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR const & releaseCapturedPipelineDataInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pipeline );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT>
{

304
include/vulkan/vulkan_raii.hpp
View file

@ -1677,6 +1677,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) );
//=== VK_KHR_pipeline_binary ===
vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) );
vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) );
vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) );
vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) );
vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) );
//=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM =
@ -2564,6 +2571,13 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0;
//=== VK_KHR_pipeline_binary ===
PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0;
PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0;
PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0;
PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0;
PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0;
//=== VK_QCOM_tile_properties ===
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
@ -2700,6 +2714,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object ===
class ShaderEXT;
//=== VK_KHR_pipeline_binary ===
class PipelineBinaryKHR;
//====================
//=== RAII HANDLES ===
//====================
@ -4562,6 +4579,23 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
VULKAN_HPP_RAII_CREATE_NOEXCEPT;
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_NODISCARD
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR>>::Type
createPipelineBinariesKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR getPipelineKeyKHR(
Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>>
getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info ) const;
void releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_QCOM_tile_properties ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
@ -9749,6 +9783,157 @@ namespace VULKAN_HPP_NAMESPACE
}
};
class PipelineBinaryKHR
{
public:
using CType = VkPipelineBinaryKHR;
using CppType = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
PipelineBinaryKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VkPipelineBinaryKHR pipelineBinary,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr,
VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess )
: m_device( device )
, m_pipelineBinary( pipelineBinary )
, m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
, m_constructorSuccessCode( successCode )
, m_dispatcher( device.getDispatcher() )
{
}
PipelineBinaryKHR( std::nullptr_t ) {}
~PipelineBinaryKHR()
{
clear();
}
PipelineBinaryKHR() = delete;
PipelineBinaryKHR( PipelineBinaryKHR const & ) = delete;
PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_pipelineBinary( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinary, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{
}
PipelineBinaryKHR & operator=( PipelineBinaryKHR const & ) = delete;
PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
if ( this != &rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_pipelineBinary, rhs.m_pipelineBinary );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
return *this;
}
VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & operator*() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinary;
}
operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineBinary;
}
void clear() VULKAN_HPP_NOEXCEPT
{
if ( m_pipelineBinary )
{
getDispatcher()->vkDestroyPipelineBinaryKHR( static_cast<VkDevice>( m_device ),
static_cast<VkPipelineBinaryKHR>( m_pipelineBinary ),
reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
}
m_device = nullptr;
m_pipelineBinary = nullptr;
m_allocator = nullptr;
m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
m_dispatcher = nullptr;
}
VULKAN_HPP_NAMESPACE::PipelineBinaryKHR release()
{
m_device = nullptr;
m_allocator = nullptr;
m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::exchange( m_pipelineBinary, nullptr );
}
VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const
{
return m_constructorSuccessCode;
}
VULKAN_HPP_NAMESPACE::Device getDevice() const
{
return m_device;
}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
{
VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR & rhs ) VULKAN_HPP_NOEXCEPT
{
std::swap( m_device, rhs.m_device );
std::swap( m_pipelineBinary, rhs.m_pipelineBinary );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinary = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
class PipelineBinaryKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR>
{
public:
# if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
PipelineBinaryKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
{
*this = device.createPipelineBinariesKHR( createInfo, allocator );
}
# endif
PipelineBinaryKHRs( std::nullptr_t ) {}
PipelineBinaryKHRs() = delete;
PipelineBinaryKHRs( PipelineBinaryKHRs const & ) = delete;
PipelineBinaryKHRs( PipelineBinaryKHRs && rhs ) = default;
PipelineBinaryKHRs & operator=( PipelineBinaryKHRs const & ) = delete;
PipelineBinaryKHRs & operator=( PipelineBinaryKHRs && rhs ) = default;
private:
PipelineBinaryKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> && rhs )
{
std::swap( *this, rhs );
}
};
class PipelineLayout
{
public:
@ -22631,6 +22816,125 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkShaderEXT *>( shaders.data() ) );
}
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR>>::Type
Device::createPipelineBinariesKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
{
std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> pipelineBinaries;
VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries;
VULKAN_HPP_NAMESPACE::Result result;
if ( createInfo.pKeysAndDataInfo )
{
VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo );
pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount );
binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount;
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR(
static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
else
{
VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR(
static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaries.resize( binaries.pipelineBinaryCount );
binaries.pPipelineBinaries = pipelineBinaries.data();
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR(
static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) );
}
}
if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) &&
( result != VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR ) )
{
# if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
return VULKAN_HPP_UNEXPECTED( result );
# else
VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineBinariesKHR" );
# endif
}
std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> pipelineBinariesRAII;
pipelineBinariesRAII.reserve( pipelineBinaries.size() );
for ( auto & pipelineBinary : pipelineBinaries )
{
pipelineBinariesRAII.emplace_back( *this, *reinterpret_cast<VkPipelineBinaryKHR *>( &pipelineBinary ), allocator, result );
}
return pipelineBinariesRAII;
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR
Device::getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineKeyKHR && "Function <vkGetPipelineKeyKHR> requires <VK_KHR_pipeline_binary>" );
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR pipelineKey;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineKeyKHR(
static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineCreateInfoKHR *>( static_cast<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR *>( pipelineCreateInfo ) ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineKey ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" );
return pipelineKey;
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>>
Device::getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" );
std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>> data_;
VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first;
std::vector<uint8_t> & pipelineBinaryData = data_.second;
size_t pipelineBinaryDataSize;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
nullptr ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
pipelineBinaryData.resize( pipelineBinaryDataSize );
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ),
reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ),
&pipelineBinaryDataSize,
reinterpret_cast<void *>( pipelineBinaryData.data() ) ) );
}
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" );
return data_;
}
VULKAN_HPP_INLINE void
Device::releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info,
Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" );
getDispatcher()->vkReleaseCapturedPipelineDataKHR(
static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ),
reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
}
//=== VK_QCOM_tile_properties ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const

11
include/vulkan/vulkan_shared.hpp
View file

@ -960,6 +960,17 @@ namespace VULKAN_HPP_NAMESPACE
using SharedShaderEXT = SharedHandle<ShaderEXT>;
//=== VK_KHR_pipeline_binary ===
template <>
class SharedHandleTraits<PipelineBinaryKHR>
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineBinaryKHR>;
};
using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
enum class SwapchainOwns
{
no,

83
include/vulkan/vulkan_static_assertions.hpp
View file

@ -6960,6 +6960,89 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ShaderCr
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT>::value,
"ShaderCreateInfoEXT is not nothrow_move_constructible!" );
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR>::value,
"PhysicalDevicePipelineBinaryFeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR>::value,
"PhysicalDevicePipelineBinaryPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR ) ==
sizeof( VkDevicePipelineBinaryInternalCacheControlKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR>::value,
"DevicePipelineBinaryInternalCacheControlKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR ) == sizeof( VkPipelineBinaryKHR ), "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>::value, "PipelineBinaryKHR is not copy_constructible!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>::value,
"PipelineBinaryKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR ) == sizeof( VkPipelineBinaryKeyKHR ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::value,
"PipelineBinaryKeyKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR ) == sizeof( VkPipelineBinaryDataKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR>::value,
"PipelineBinaryDataKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR ) == sizeof( VkPipelineBinaryKeysAndDataKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR>::value,
"PipelineBinaryKeysAndDataKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR ) == sizeof( VkPipelineBinaryCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR>::value,
"PipelineBinaryCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR ) == sizeof( VkPipelineBinaryInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR>::value,
"PipelineBinaryInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR ) == sizeof( VkReleaseCapturedPipelineDataInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR>::value,
"ReleaseCapturedPipelineDataInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR ) == sizeof( VkPipelineBinaryDataInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR>::value,
"PipelineBinaryDataInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR ) == sizeof( VkPipelineCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR>::value,
"PipelineCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR ) == sizeof( VkPipelineBinaryHandlesInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR>::value,
"PipelineBinaryHandlesInfoKHR is not nothrow_move_constructible!" );
//=== VK_QCOM_tile_properties ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ),

1349
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

16
include/vulkan/vulkan_to_string.hpp
View file

@ -3430,6 +3430,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "RayTracingDisplacementMicromapNV | ";
if ( value & PipelineCreateFlagBits2KHR::eDescriptorBufferEXT )
result += "DescriptorBufferEXT | ";
if ( value & PipelineCreateFlagBits2KHR::eCaptureData )
result += "CaptureData | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -3594,6 +3596,8 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR";
case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT";
case Result::eIncompatibleShaderBinaryEXT: return "IncompatibleShaderBinaryEXT";
case Result::ePipelineBinaryMissingKHR: return "PipelineBinaryMissingKHR";
case Result::eErrorNotEnoughSpaceKHR: return "ErrorNotEnoughSpaceKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -4476,6 +4480,16 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceShaderObjectFeaturesEXT: return "PhysicalDeviceShaderObjectFeaturesEXT";
case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT: return "PhysicalDeviceShaderObjectPropertiesEXT";
case StructureType::eShaderCreateInfoEXT: return "ShaderCreateInfoEXT";
case StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR: return "PhysicalDevicePipelineBinaryFeaturesKHR";
case StructureType::ePipelineBinaryCreateInfoKHR: return "PipelineBinaryCreateInfoKHR";
case StructureType::ePipelineBinaryInfoKHR: return "PipelineBinaryInfoKHR";
case StructureType::ePipelineBinaryKeyKHR: return "PipelineBinaryKeyKHR";
case StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR: return "PhysicalDevicePipelineBinaryPropertiesKHR";
case StructureType::eReleaseCapturedPipelineDataInfoKHR: return "ReleaseCapturedPipelineDataInfoKHR";
case StructureType::ePipelineBinaryDataInfoKHR: return "PipelineBinaryDataInfoKHR";
case StructureType::ePipelineCreateInfoKHR: return "PipelineCreateInfoKHR";
case StructureType::eDevicePipelineBinaryInternalCacheControlKHR: return "DevicePipelineBinaryInternalCacheControlKHR";
case StructureType::ePipelineBinaryHandlesInfoKHR: return "PipelineBinaryHandlesInfoKHR";
case StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM: return "PhysicalDeviceTilePropertiesFeaturesQCOM";
case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM";
case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC";
@ -4640,6 +4654,7 @@ namespace VULKAN_HPP_NAMESPACE
case ObjectType::eMicromapEXT: return "MicromapEXT";
case ObjectType::eOpticalFlowSessionNV: return "OpticalFlowSessionNV";
case ObjectType::eShaderEXT: return "ShaderEXT";
case ObjectType::ePipelineBinaryKHR: return "PipelineBinaryKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -8862,6 +8877,7 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT: return "ProtectedAccessOnlyEXT";
case PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
case PipelineCreateFlagBits2KHR::eDescriptorBufferEXT: return "DescriptorBufferEXT";
case PipelineCreateFlagBits2KHR::eCaptureData: return "CaptureData";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

780
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

417
registry/vk.xml
View file

File diff suppressed because it is too large Load diff