organicmaps/Vulkan-Headers
13
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers.git synced 2025-04-04 12:45:00 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

Update for Vulkan-Docs 1.3.280

Browse source
This commit is contained in:
Jon Leech 2024-03-08 05:12:01 -08:00 • committed by Jon Leech
parent f030d9dd8c
commit 577baa0503
14 changed files with 1127 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
include/vulkan/vulkan.cppm
View file

@ -2502,6 +2502,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName;
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion;
//=== VK_NV_ray_tracing_validation ===
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -4345,6 +4349,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_shader_atomic_float16_vector ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
//=== VK_NV_ray_tracing_validation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
//===============
//=== HANDLEs ===
//===============

25
include/vulkan/vulkan.hpp
View file

@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 279, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 280, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -8670,6 +8670,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
//=== VK_NV_ray_tracing_validation ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -16639,6 +16643,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_NV_ray_tracing_validation ===
template <>
struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL

15
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 279
#define VK_HEADER_VERSION 280
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@ -1111,6 +1111,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@ -19134,6 +19135,18 @@ typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_ray_tracing_validation 1
#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1
#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation"
typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 rayTracingValidation;
} VkPhysicalDeviceRayTracingValidationFeaturesNV;
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

3
include/vulkan/vulkan_enums.hpp
View file

@ -1423,7 +1423,8 @@ namespace VULKAN_HPP_NAMESPACE
eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT,
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV
ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV,
ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV
};
enum class PipelineCacheHeaderVersion

5
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -435,7 +435,8 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_maintenance6",
"VK_NV_descriptor_pool_overallocation",
"VK_NV_raw_access_chains",
"VK_NV_shader_atomic_float16_vector"
"VK_NV_shader_atomic_float16_vector",
"VK_NV_ray_tracing_validation"
};
return deviceExtensions;
}
@ -2876,7 +2877,7 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_NV_shader_atomic_float16_vector" );
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_NV_ray_tracing_validation" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

110
include/vulkan/vulkan_funcs.hpp
View file

@ -2146,7 +2146,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
return ResultValue<std::vector<DataType, DataTypeAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( data ) );
return ResultValue<std::vector<DataType, DataTypeAllocator>>( result, std::move( data ) );
}
template <typename DataType, typename Dispatch>
@ -2174,7 +2174,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck(
result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
return ResultValue<DataType>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( data ) );
return ResultValue<DataType>( result, std::move( data ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3038,8 +3038,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename PipelineAllocator,
@ -3069,8 +3068,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename Dispatch>
@ -3097,7 +3095,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( pipeline ) );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -3131,8 +3129,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <
@ -3169,8 +3166,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <typename Dispatch>
@ -3198,8 +3194,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3246,8 +3241,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename PipelineAllocator,
@ -3277,8 +3271,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename Dispatch>
@ -3305,7 +3298,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( pipeline ) );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -3339,8 +3332,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <
@ -3377,8 +3369,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <typename Dispatch>
@ -3406,8 +3397,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8784,7 +8774,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return ResultValue<uint32_t>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( imageIndex ) );
return ResultValue<uint32_t>( result, std::move( imageIndex ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8984,7 +8974,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return ResultValue<uint32_t>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( imageIndex ) );
return ResultValue<uint32_t>( result, std::move( imageIndex ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -15186,8 +15176,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename PipelineAllocator,
@ -15217,8 +15206,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename Dispatch>
@ -15245,7 +15233,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( pipeline ) );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -15280,8 +15268,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <
@ -15319,8 +15306,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <typename Dispatch>
@ -15348,8 +15334,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -16486,8 +16471,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename PipelineAllocator,
@ -16522,8 +16506,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename Dispatch>
@ -16555,7 +16538,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( pipeline ) );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -16595,8 +16578,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <
@ -16639,8 +16621,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <typename Dispatch>
@ -16673,8 +16654,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -17670,8 +17650,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename PipelineAllocator,
@ -17701,8 +17680,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( pipelines ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( result, std::move( pipelines ) );
}
template <typename Dispatch>
@ -17729,7 +17707,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( pipeline ) );
return ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>( result, std::move( pipeline ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -17763,8 +17741,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <
@ -17801,8 +17778,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniquePipelines ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>( result, std::move( uniquePipelines ) );
}
template <typename Dispatch>
@ -17830,8 +17806,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -25411,8 +25386,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( shaders ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) );
}
template <typename ShaderEXTAllocator,
@ -25440,8 +25414,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
std::move( shaders ) );
return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>( result, std::move( shaders ) );
}
template <typename Dispatch>
@ -25466,7 +25439,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
return ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( shader ) );
return ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT>( result, std::move( shader ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -25498,8 +25471,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniqueShaders ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) );
}
template <
@ -25534,8 +25506,7 @@ namespace VULKAN_HPP_NAMESPACE
{
uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
}
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( uniqueShaders ) );
return ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) );
}
template <typename Dispatch>
@ -25561,8 +25532,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>( shader, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>( shader, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

3
include/vulkan/vulkan_handles.hpp
View file

@ -1826,6 +1826,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_shader_atomic_float16_vector ===
struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
//=== VK_NV_ray_tracing_validation ===
struct PhysicalDeviceRayTracingValidationFeaturesNV;
//===================================
//=== HANDLE forward declarations ===
//===================================

14
include/vulkan/vulkan_hash.hpp
View file

@ -10812,6 +10812,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>
{

8
include/vulkan/vulkan_raii.hpp
View file

@ -12628,7 +12628,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck(
result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( data ) );
return std::make_pair( result, std::move( data ) );
}
template <typename DataType>
@ -12650,7 +12650,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck(
result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( data ) );
return std::make_pair( result, std::move( data ) );
}
VULKAN_HPP_NODISCARD
@ -15138,7 +15138,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( imageIndex ) );
return std::make_pair( result, std::move( imageIndex ) );
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const
@ -15227,7 +15227,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), std::move( imageIndex ) );
return std::make_pair( result, std::move( imageIndex ) );
}
//=== VK_KHR_display ===

10
include/vulkan/vulkan_static_assertions.hpp
View file

@ -7493,4 +7493,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>::value,
"PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" );
//=== VK_NV_ray_tracing_validation ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV ) ==
sizeof( VkPhysicalDeviceRayTracingValidationFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
"PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );
#endif

98
include/vulkan/vulkan_structs.hpp
View file

@ -79489,6 +79489,104 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceRayTracingPropertiesNV;
};
struct PhysicalDeviceRayTracingValidationFeaturesNV
{
using NativeType = VkPhysicalDeviceRayTracingValidationFeaturesNV;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 rayTracingValidation_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, rayTracingValidation( rayTracingValidation_ )
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceRayTracingValidationFeaturesNV( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceRayTracingValidationFeaturesNV( *reinterpret_cast<PhysicalDeviceRayTracingValidationFeaturesNV const *>( &rhs ) )
{
}
PhysicalDeviceRayTracingValidationFeaturesNV & operator=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceRayTracingValidationFeaturesNV & operator=( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV &
setRayTracingValidation( VULKAN_HPP_NAMESPACE::Bool32 rayTracingValidation_ ) VULKAN_HPP_NOEXCEPT
{
rayTracingValidation = rayTracingValidation_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceRayTracingValidationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>( this );
}
operator VkPhysicalDeviceRayTracingValidationFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, rayTracingValidation );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayTracingValidationFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingValidation == rhs.rayTracingValidation );
# endif
}
bool operator!=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 rayTracingValidation = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV>
{
using Type = PhysicalDeviceRayTracingValidationFeaturesNV;
};
struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG
{
using NativeType = VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG;

1
include/vulkan/vulkan_to_string.hpp
View file

@ -4549,6 +4549,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

1017
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

19
registry/vk.xml
View file

@ -175,7 +175,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
<type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 279</type>
#define <name>VK_HEADER_VERSION</name> 280</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -7557,6 +7557,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>rayTracingMotionBlur</name></member>
<member><type>VkBool32</type> <name>rayTracingMotionBlurPipelineTraceRaysIndirect</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRayTracingValidationFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>rayTracingValidation</name></member>
</type>
<type name="VkAccelerationStructureMotionInstanceTypeNV" category="enum"/>
<type category="struct" name="VkAccelerationStructureGeometryMotionTrianglesDataNV" structextends="VkAccelerationStructureGeometryTrianglesDataKHR">
<member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"><type>VkStructureType</type> <name>sType</name></member>
@ -24187,6 +24192,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_NV_EXTENSION_551_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_551&quot;" name="VK_NV_EXTENSION_551_EXTENSION_NAME"/>
<enum bitpos="45" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_RESERVED_45_BIT_NV"/>
<enum bitpos="55" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_55_BIT_NV"/>
<enum bitpos="56" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_56_BIT_NV"/>
</require>
</extension>
<extension name="VK_NV_extension_552" number="552" author="NV" contact="Russell Chou @russellcnv" supported="disabled">
@ -24271,7 +24279,6 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_KHR_EXTENSION_563_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_563&quot;" name="VK_KHR_EXTENSION_563_EXTENSION_NAME"/>
<enum bitpos="43" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_43_BIT_KHR"/>
</require>
</extension>
<extension name="VK_NV_shader_atomic_float16_vector" number="564" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
@ -24306,10 +24313,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_ARM_extension_568&quot;" name="VK_ARM_EXTENSION_568_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_569" number="569" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
<extension name="VK_NV_ray_tracing_validation" number="569" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
<require>
<enum value="0" name="VK_NV_EXTENSION_569_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_569&quot;" name="VK_NV_EXTENSION_569_EXTENSION_NAME"/>
<enum value="1" name="VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION"/>
<enum value="&quot;VK_NV_ray_tracing_validation&quot;" name="VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV"/>
<type name="VkPhysicalDeviceRayTracingValidationFeaturesNV"/>
</require>
</extension>
<extension name="VK_NV_extension_570" number="570" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">