Update Vulkan-Headers to v1.3.294 (#1951)

Co-authored-by: GitHub <noreply@github.com>
This commit is contained in:
github-actions[bot] 2024-08-26 16:06:58 +02:00 committed by GitHub
parent ecd4b59328
commit bd70384cd4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 2923 additions and 22 deletions

@ -1 +1 @@
Subproject commit d205aff40b4e15d4c568523ee6a26f85138126d9 Subproject commit a6a5dc0d078ade9bde75bd78404462509cbdce99

View File

@ -941,6 +941,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError; using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError;
using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError; using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
using VULKAN_HPP_NAMESPACE::NotEnoughSpaceKHRError;
#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ #endif /*VULKAN_HPP_NO_EXCEPTIONS*/
using VULKAN_HPP_NAMESPACE::ResultValue; using VULKAN_HPP_NAMESPACE::ResultValue;
@ -2399,6 +2400,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderObjectExtensionName; using VULKAN_HPP_NAMESPACE::EXTShaderObjectExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderObjectSpecVersion; using VULKAN_HPP_NAMESPACE::EXTShaderObjectSpecVersion;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::KHRPipelineBinaryExtensionName;
using VULKAN_HPP_NAMESPACE::KHRPipelineBinarySpecVersion;
//=== VK_QCOM_tile_properties === //=== VK_QCOM_tile_properties ===
using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesExtensionName; using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesSpecVersion; using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesSpecVersion;
@ -4256,6 +4261,20 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT; using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT;
using VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT; 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 === //=== VK_QCOM_tile_properties ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM; using VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM; using VULKAN_HPP_NAMESPACE::TilePropertiesQCOM;
@ -4544,6 +4563,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::ShaderEXT; using VULKAN_HPP_NAMESPACE::ShaderEXT;
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
//====================== //======================
//=== UNIQUE HANDLEs === //=== UNIQUE HANDLEs ===
//====================== //======================
@ -4641,8 +4663,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV; using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV;
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
using VULKAN_HPP_NAMESPACE::UniqueShaderEXT; 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*/ #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//====================== //======================
@ -4745,8 +4770,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV; using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
using VULKAN_HPP_NAMESPACE::SharedShaderEXT; 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*/ #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::ShaderEXT;
using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs; 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 } // namespace VULKAN_HPP_RAII_NAMESPACE
#endif #endif
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE

View File

@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span> # include <span>
#endif #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 // <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x) // this results in major(x) being resolved to gnu_dev_major(x)
@ -5742,6 +5742,44 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders ); 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 === //=== VK_QCOM_tile_properties ===
VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device, VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device,
@ -6519,6 +6557,14 @@ namespace VULKAN_HPP_NAMESPACE
CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} 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 namespace detail
{ {
[[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
@ -6561,6 +6607,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message ); case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message );
case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message ); case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
case Result::eErrorNotEnoughSpaceKHR: throw NotEnoughSpaceKHRError( message );
default: throw SystemError( make_error_code( result ), message ); default: throw SystemError( make_error_code( result ), message );
} }
} }
@ -8348,6 +8395,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION; 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 === //=== VK_QCOM_tile_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION;
@ -8541,6 +8592,24 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
template <>
struct StructExtends<ComputePipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<GraphicsPipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <> template <>
struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR> struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR>
{ {
@ -11256,6 +11325,15 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
template <>
struct StructExtends<ExecutionGraphPipelineCreateInfoAMDX, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <> template <>
struct StructExtends<PipelineShaderStageNodeCreateInfoAMDX, PipelineShaderStageCreateInfo> struct StructExtends<PipelineShaderStageNodeCreateInfoAMDX, PipelineShaderStageCreateInfo>
{ {
@ -11397,6 +11475,15 @@ namespace VULKAN_HPP_NAMESPACE
}; };
//=== VK_KHR_ray_tracing_pipeline === //=== VK_KHR_ray_tracing_pipeline ===
template <>
struct StructExtends<RayTracingPipelineCreateInfoKHR, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <> template <>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2> struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>
{ {
@ -11623,6 +11710,15 @@ namespace VULKAN_HPP_NAMESPACE
}; };
//=== VK_NV_ray_tracing === //=== VK_NV_ray_tracing ===
template <>
struct StructExtends<RayTracingPipelineCreateInfoNV, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <> template <>
struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet> struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>
{ {
@ -15631,6 +15727,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 === //=== VK_QCOM_tile_properties ===
template <> template <>
struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2> struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2>
@ -16744,7 +16904,7 @@ namespace VULKAN_HPP_NAMESPACE
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL ); m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
} }
# elif defined( _WIN32 ) # elif defined( _WIN32 )
m_library = ::LoadLibraryA( "vulkan-1.dll" ); m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else # else
# error unsupported platform # error unsupported platform
# endif # endif
@ -17911,6 +18071,13 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 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 === //=== VK_QCOM_tile_properties ===
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
@ -19316,6 +19483,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) ); vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) ); 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 === //=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM = vkGetDynamicRenderingTilePropertiesQCOM =
@ -20369,6 +20543,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); 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 === //=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM = vkGetDynamicRenderingTilePropertiesQCOM =

View File

@ -284,7 +284,9 @@ namespace VULKAN_HPP_NAMESPACE
eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR,
eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT, eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT,
eIncompatibleShaderBinaryEXT = VK_INCOMPATIBLE_SHADER_BINARY_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 enum class StructureType
@ -1336,6 +1338,16 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT,
eShaderCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_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, ePhysicalDeviceTilePropertiesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM,
eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM,
ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC,
@ -1503,7 +1515,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_FUCHSIA*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/
eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT, eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT,
eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, 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 enum class VendorId
@ -7014,7 +7027,8 @@ namespace VULKAN_HPP_NAMESPACE
eNoProtectedAccessEXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT, eNoProtectedAccessEXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT,
eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT, eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT,
eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, 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>; using PipelineCreateFlags2KHR = Flags<PipelineCreateFlagBits2KHR>;
@ -7038,7 +7052,8 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCreateFlagBits2KHR::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2KHR::eRayTracingOpacityMicromapEXT | PipelineCreateFlagBits2KHR::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2KHR::eRayTracingOpacityMicromapEXT |
PipelineCreateFlagBits2KHR::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2KHR::eDepthStencilAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2KHR::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2KHR::eDepthStencilAttachmentFeedbackLoopEXT |
PipelineCreateFlagBits2KHR::eNoProtectedAccessEXT | PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT | PipelineCreateFlagBits2KHR::eNoProtectedAccessEXT | PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT |
PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2KHR::eDescriptorBufferEXT; PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2KHR::eDescriptorBufferEXT |
PipelineCreateFlagBits2KHR::eCaptureData;
}; };
enum class BufferUsageFlagBits2KHR : VkBufferUsageFlags2KHR enum class BufferUsageFlagBits2KHR : VkBufferUsageFlags2KHR
@ -7463,7 +7478,11 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
//=== VK_EXT_shader_object === //=== 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; default: VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
} }

View File

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

View File

@ -25732,6 +25732,469 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #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 === //=== VK_QCOM_tile_properties ===
template <typename Dispatch> template <typename Dispatch>

View File

@ -1676,6 +1676,20 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceShaderObjectPropertiesEXT; struct PhysicalDeviceShaderObjectPropertiesEXT;
struct ShaderCreateInfoEXT; 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 === //=== VK_QCOM_tile_properties ===
struct PhysicalDeviceTilePropertiesFeaturesQCOM; struct PhysicalDeviceTilePropertiesFeaturesQCOM;
struct TilePropertiesQCOM; struct TilePropertiesQCOM;
@ -1962,6 +1976,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
class ShaderEXT; class ShaderEXT;
//=== VK_KHR_pipeline_binary ===
class PipelineBinaryKHR;
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
//====================== //======================
//=== UNIQUE HANDLEs === //=== UNIQUE HANDLEs ===
@ -2417,6 +2434,16 @@ namespace VULKAN_HPP_NAMESPACE
}; };
using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; 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*/ #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//=============== //===============
@ -9714,6 +9741,110 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; 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 class Queue
{ {
public: 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; VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #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 === //=== VK_QCOM_tile_properties ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

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 #if 14 <= VULKAN_HPP_CPP_VERSION
//====================================== //======================================
//=== HASH structures for structures === //=== 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 <> template <>
struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo> 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 <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures> 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 <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo> 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 <> template <>
struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT> struct hash<VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT>
{ {

View File

@ -1677,6 +1677,13 @@ namespace VULKAN_HPP_NAMESPACE
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); 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 === //=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM = vkGetDynamicRenderingTilePropertiesQCOM =
@ -2564,6 +2571,13 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 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 === //=== VK_QCOM_tile_properties ===
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
@ -2700,6 +2714,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
class ShaderEXT; class ShaderEXT;
//=== VK_KHR_pipeline_binary ===
class PipelineBinaryKHR;
//==================== //====================
//=== RAII HANDLES === //=== RAII HANDLES ===
//==================== //====================
@ -4562,6 +4579,23 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
VULKAN_HPP_RAII_CREATE_NOEXCEPT; 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 === //=== VK_QCOM_tile_properties ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM 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 class PipelineLayout
{ {
public: public:
@ -22631,6 +22816,125 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkShaderEXT *>( shaders.data() ) ); 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 === //=== VK_QCOM_tile_properties ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const

View File

@ -960,6 +960,17 @@ namespace VULKAN_HPP_NAMESPACE
using SharedShaderEXT = SharedHandle<ShaderEXT>; 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 enum class SwapchainOwns
{ {
no, no,

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, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT>::value,
"ShaderCreateInfoEXT is not nothrow_move_constructible!" ); "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 === //=== VK_QCOM_tile_properties ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ),

File diff suppressed because it is too large Load Diff

View File

@ -3430,6 +3430,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "RayTracingDisplacementMicromapNV | "; result += "RayTracingDisplacementMicromapNV | ";
if ( value & PipelineCreateFlagBits2KHR::eDescriptorBufferEXT ) if ( value & PipelineCreateFlagBits2KHR::eDescriptorBufferEXT )
result += "DescriptorBufferEXT | "; result += "DescriptorBufferEXT | ";
if ( value & PipelineCreateFlagBits2KHR::eCaptureData )
result += "CaptureData | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -3594,6 +3596,8 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR"; case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR";
case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT"; case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT";
case Result::eIncompatibleShaderBinaryEXT: return "IncompatibleShaderBinaryEXT"; 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 ) ) + " )"; 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::ePhysicalDeviceShaderObjectFeaturesEXT: return "PhysicalDeviceShaderObjectFeaturesEXT";
case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT: return "PhysicalDeviceShaderObjectPropertiesEXT"; case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT: return "PhysicalDeviceShaderObjectPropertiesEXT";
case StructureType::eShaderCreateInfoEXT: return "ShaderCreateInfoEXT"; 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::ePhysicalDeviceTilePropertiesFeaturesQCOM: return "PhysicalDeviceTilePropertiesFeaturesQCOM";
case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM"; case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM";
case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC"; case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC";
@ -4640,6 +4654,7 @@ namespace VULKAN_HPP_NAMESPACE
case ObjectType::eMicromapEXT: return "MicromapEXT"; case ObjectType::eMicromapEXT: return "MicromapEXT";
case ObjectType::eOpticalFlowSessionNV: return "OpticalFlowSessionNV"; case ObjectType::eOpticalFlowSessionNV: return "OpticalFlowSessionNV";
case ObjectType::eShaderEXT: return "ShaderEXT"; case ObjectType::eShaderEXT: return "ShaderEXT";
case ObjectType::ePipelineBinaryKHR: return "PipelineBinaryKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; 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::eProtectedAccessOnlyEXT: return "ProtectedAccessOnlyEXT";
case PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; case PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
case PipelineCreateFlagBits2KHR::eDescriptorBufferEXT: return "DescriptorBufferEXT"; case PipelineCreateFlagBits2KHR::eDescriptorBufferEXT: return "DescriptorBufferEXT";
case PipelineCreateFlagBits2KHR::eCaptureData: return "CaptureData";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }

View File

@ -4357,6 +4357,24 @@ namespace VULKAN_HPP_NAMESPACE
//======================= //=======================
//=== VK_VERSION_1_0 === //=== VK_VERSION_1_0 ===
template <>
struct StructExtends<ComputePipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<GraphicsPipelineCreateInfo, PipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <> template <>
struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR> struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR>
{ {
@ -7070,7 +7088,7 @@ namespace VULKAN_HPP_NAMESPACE
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL ); m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
} }
# elif defined( _WIN32 ) # elif defined( _WIN32 )
m_library = ::LoadLibraryA( "vulkan-1.dll" ); m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else # else
# error unsupported platform # error unsupported platform
# endif # endif