eden-emu/Vulkan-Utility-Libraries
14
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git synced 2025-05-15 01:08:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

build: Update to header 1.4.307

Browse source
This commit is contained in:
Mike Schuchardt 2025-01-30 08:59:00 -08:00
parent 1ddbe6c40a
commit fe7a09b138
11 changed files with 2755 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

14
include/vulkan/utility/vk_dispatch_table.h
View file

@ -161,6 +161,7 @@ typedef struct VkuInstanceDispatchTable_ {
PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX;
#endif // VK_USE_PLATFORM_SCREEN_QNX
PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV;
PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV GetPhysicalDeviceCooperativeVectorPropertiesNV;
PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
} VkuInstanceDispatchTable;
@ -750,6 +751,8 @@ typedef struct VkuDeviceDispatchTable_ {
PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT;
PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM;
PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM;
PFN_vkConvertCooperativeVectorMatrixNV ConvertCooperativeVectorMatrixNV;
PFN_vkCmdConvertCooperativeVectorMatrixNV CmdConvertCooperativeVectorMatrixNV;
PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV;
PFN_vkLatencySleepNV LatencySleepNV;
PFN_vkSetLatencyMarkerNV SetLatencyMarkerNV;
@ -759,6 +762,10 @@ typedef struct VkuDeviceDispatchTable_ {
#ifdef VK_USE_PLATFORM_SCREEN_QNX
PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
#endif // VK_USE_PLATFORM_SCREEN_QNX
PFN_vkGetClusterAccelerationStructureBuildSizesNV GetClusterAccelerationStructureBuildSizesNV;
PFN_vkCmdBuildClusterAccelerationStructureIndirectNV CmdBuildClusterAccelerationStructureIndirectNV;
PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV GetPartitionedAccelerationStructuresBuildSizesNV;
PFN_vkCmdBuildPartitionedAccelerationStructuresNV CmdBuildPartitionedAccelerationStructuresNV;
PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT;
PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT;
PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT;
@ -1386,6 +1393,8 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
table->CmdSetDepthClampRangeEXT = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT");
table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(device, "vkGetFramebufferTilePropertiesQCOM");
table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(device, "vkGetDynamicRenderingTilePropertiesQCOM");
table->ConvertCooperativeVectorMatrixNV = (PFN_vkConvertCooperativeVectorMatrixNV)gdpa(device, "vkConvertCooperativeVectorMatrixNV");
table->CmdConvertCooperativeVectorMatrixNV = (PFN_vkCmdConvertCooperativeVectorMatrixNV)gdpa(device, "vkCmdConvertCooperativeVectorMatrixNV");
table->SetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)gdpa(device, "vkSetLatencySleepModeNV");
table->LatencySleepNV = (PFN_vkLatencySleepNV)gdpa(device, "vkLatencySleepNV");
table->SetLatencyMarkerNV = (PFN_vkSetLatencyMarkerNV)gdpa(device, "vkSetLatencyMarkerNV");
@ -1395,6 +1404,10 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
#ifdef VK_USE_PLATFORM_SCREEN_QNX
table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
#endif // VK_USE_PLATFORM_SCREEN_QNX
table->GetClusterAccelerationStructureBuildSizesNV = (PFN_vkGetClusterAccelerationStructureBuildSizesNV)gdpa(device, "vkGetClusterAccelerationStructureBuildSizesNV");
table->CmdBuildClusterAccelerationStructureIndirectNV = (PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)gdpa(device, "vkCmdBuildClusterAccelerationStructureIndirectNV");
table->GetPartitionedAccelerationStructuresBuildSizesNV = (PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)gdpa(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV");
table->CmdBuildPartitionedAccelerationStructuresNV = (PFN_vkCmdBuildPartitionedAccelerationStructuresNV)gdpa(device, "vkCmdBuildPartitionedAccelerationStructuresNV");
table->GetGeneratedCommandsMemoryRequirementsEXT = (PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)gdpa(device, "vkGetGeneratedCommandsMemoryRequirementsEXT");
table->CmdPreprocessGeneratedCommandsEXT = (PFN_vkCmdPreprocessGeneratedCommandsEXT)gdpa(device, "vkCmdPreprocessGeneratedCommandsEXT");
table->CmdExecuteGeneratedCommandsEXT = (PFN_vkCmdExecuteGeneratedCommandsEXT)gdpa(device, "vkCmdExecuteGeneratedCommandsEXT");
@ -1575,6 +1588,7 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX");
#endif // VK_USE_PLATFORM_SCREEN_QNX
table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
table->GetPhysicalDeviceCooperativeVectorPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV");
table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
}
// clang-format on

590
include/vulkan/utility/vk_safe_struct.hpp
View file

@ -3,10 +3,10 @@
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
@ -17266,6 +17266,91 @@ struct safe_VkPipelineIndirectDeviceAddressInfoNV {
return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV const*>(this);
}
};
struct safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
VkStructureType sType;
void* pNext{};
VkBool32 spheres;
VkBool32 linearSweptSpheres;
safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src);
safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& operator=(
const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src);
safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV();
~safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV();
void initialize(const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(this);
}
VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const*>(this);
}
};
struct safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
VkStructureType sType;
const void* pNext{};
VkFormat vertexFormat;
safe_VkDeviceOrHostAddressConstKHR vertexData;
VkDeviceSize vertexStride;
VkFormat radiusFormat;
safe_VkDeviceOrHostAddressConstKHR radiusData;
VkDeviceSize radiusStride;
VkIndexType indexType;
safe_VkDeviceOrHostAddressConstKHR indexData;
VkDeviceSize indexStride;
VkRayTracingLssIndexingModeNV indexingMode;
VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode;
safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src);
safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& operator=(
const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src);
safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV();
~safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV();
void initialize(const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV* copy_src, PNextCopyState* copy_state = {});
VkAccelerationStructureGeometryLinearSweptSpheresDataNV* ptr() {
return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(this);
}
VkAccelerationStructureGeometryLinearSweptSpheresDataNV const* ptr() const {
return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV const*>(this);
}
};
struct safe_VkAccelerationStructureGeometrySpheresDataNV {
VkStructureType sType;
const void* pNext{};
VkFormat vertexFormat;
safe_VkDeviceOrHostAddressConstKHR vertexData;
VkDeviceSize vertexStride;
VkFormat radiusFormat;
safe_VkDeviceOrHostAddressConstKHR radiusData;
VkDeviceSize radiusStride;
VkIndexType indexType;
safe_VkDeviceOrHostAddressConstKHR indexData;
VkDeviceSize indexStride;
safe_VkAccelerationStructureGeometrySpheresDataNV(const VkAccelerationStructureGeometrySpheresDataNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkAccelerationStructureGeometrySpheresDataNV(const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src);
safe_VkAccelerationStructureGeometrySpheresDataNV& operator=(const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src);
safe_VkAccelerationStructureGeometrySpheresDataNV();
~safe_VkAccelerationStructureGeometrySpheresDataNV();
void initialize(const VkAccelerationStructureGeometrySpheresDataNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkAccelerationStructureGeometrySpheresDataNV* copy_src, PNextCopyState* copy_state = {});
VkAccelerationStructureGeometrySpheresDataNV* ptr() {
return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV*>(this);
}
VkAccelerationStructureGeometrySpheresDataNV const* ptr() const {
return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV const*>(this);
}
};
struct safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
VkStructureType sType;
void* pNext{};
@ -18195,6 +18280,101 @@ struct safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceCooperativeVectorPropertiesNV {
VkStructureType sType;
void* pNext{};
VkShaderStageFlags cooperativeVectorSupportedStages;
VkBool32 cooperativeVectorTrainingFloat16Accumulation;
VkBool32 cooperativeVectorTrainingFloat32Accumulation;
uint32_t maxCooperativeVectorComponents;
safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src);
safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& operator=(
const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src);
safe_VkPhysicalDeviceCooperativeVectorPropertiesNV();
~safe_VkPhysicalDeviceCooperativeVectorPropertiesNV();
void initialize(const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceCooperativeVectorPropertiesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceCooperativeVectorPropertiesNV*>(this);
}
VkPhysicalDeviceCooperativeVectorPropertiesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceCooperativeVectorPropertiesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceCooperativeVectorFeaturesNV {
VkStructureType sType;
void* pNext{};
VkBool32 cooperativeVector;
VkBool32 cooperativeVectorTraining;
safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src);
safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src);
safe_VkPhysicalDeviceCooperativeVectorFeaturesNV();
~safe_VkPhysicalDeviceCooperativeVectorFeaturesNV();
void initialize(const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceCooperativeVectorFeaturesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV*>(this);
}
VkPhysicalDeviceCooperativeVectorFeaturesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV const*>(this);
}
};
struct safe_VkCooperativeVectorPropertiesNV {
VkStructureType sType;
void* pNext{};
VkComponentTypeKHR inputType;
VkComponentTypeKHR inputInterpretation;
VkComponentTypeKHR matrixInterpretation;
VkComponentTypeKHR biasInterpretation;
VkComponentTypeKHR resultType;
VkBool32 transpose;
safe_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkCooperativeVectorPropertiesNV(const safe_VkCooperativeVectorPropertiesNV& copy_src);
safe_VkCooperativeVectorPropertiesNV& operator=(const safe_VkCooperativeVectorPropertiesNV& copy_src);
safe_VkCooperativeVectorPropertiesNV();
~safe_VkCooperativeVectorPropertiesNV();
void initialize(const VkCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkCooperativeVectorPropertiesNV* copy_src, PNextCopyState* copy_state = {});
VkCooperativeVectorPropertiesNV* ptr() { return reinterpret_cast<VkCooperativeVectorPropertiesNV*>(this); }
VkCooperativeVectorPropertiesNV const* ptr() const { return reinterpret_cast<VkCooperativeVectorPropertiesNV const*>(this); }
};
struct safe_VkConvertCooperativeVectorMatrixInfoNV {
VkStructureType sType;
const void* pNext{};
size_t srcSize;
safe_VkDeviceOrHostAddressConstKHR srcData;
size_t* pDstSize{};
safe_VkDeviceOrHostAddressKHR dstData;
VkComponentTypeKHR srcComponentType;
VkComponentTypeKHR dstComponentType;
uint32_t numRows;
uint32_t numColumns;
VkCooperativeVectorMatrixLayoutNV srcLayout;
size_t srcStride;
VkCooperativeVectorMatrixLayoutNV dstLayout;
size_t dstStride;
safe_VkConvertCooperativeVectorMatrixInfoNV(const VkConvertCooperativeVectorMatrixInfoNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkConvertCooperativeVectorMatrixInfoNV(const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src);
safe_VkConvertCooperativeVectorMatrixInfoNV& operator=(const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src);
safe_VkConvertCooperativeVectorMatrixInfoNV();
~safe_VkConvertCooperativeVectorMatrixInfoNV();
void initialize(const VkConvertCooperativeVectorMatrixInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkConvertCooperativeVectorMatrixInfoNV* copy_src, PNextCopyState* copy_state = {});
VkConvertCooperativeVectorMatrixInfoNV* ptr() { return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV*>(this); }
VkConvertCooperativeVectorMatrixInfoNV const* ptr() const {
return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV const*>(this);
}
};
struct safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
VkStructureType sType;
void* pNext{};
@ -19118,6 +19298,388 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
VkStructureType sType;
void* pNext{};
VkBool32 clusterAccelerationStructure;
safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src);
safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& operator=(
const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src);
safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV();
~safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV();
void initialize(const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(this);
}
VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
VkStructureType sType;
void* pNext{};
uint32_t maxVerticesPerCluster;
uint32_t maxTrianglesPerCluster;
uint32_t clusterScratchByteAlignment;
uint32_t clusterByteAlignment;
uint32_t clusterTemplateByteAlignment;
uint32_t clusterBottomLevelByteAlignment;
uint32_t clusterTemplateBoundsByteAlignment;
uint32_t maxClusterGeometryIndex;
safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src);
safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& operator=(
const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src);
safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV();
~safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV();
void initialize(const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(this);
}
VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const*>(this);
}
};
struct safe_VkClusterAccelerationStructureClustersBottomLevelInputNV {
VkStructureType sType;
void* pNext{};
uint32_t maxTotalClusterCount;
uint32_t maxClusterCountPerAccelerationStructure;
safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src);
safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& operator=(
const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src);
safe_VkClusterAccelerationStructureClustersBottomLevelInputNV();
~safe_VkClusterAccelerationStructureClustersBottomLevelInputNV();
void initialize(const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureClustersBottomLevelInputNV* ptr() {
return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV*>(this);
}
VkClusterAccelerationStructureClustersBottomLevelInputNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV const*>(this);
}
};
struct safe_VkClusterAccelerationStructureTriangleClusterInputNV {
VkStructureType sType;
void* pNext{};
VkFormat vertexFormat;
uint32_t maxGeometryIndexValue;
uint32_t maxClusterUniqueGeometryCount;
uint32_t maxClusterTriangleCount;
uint32_t maxClusterVertexCount;
uint32_t maxTotalTriangleCount;
uint32_t maxTotalVertexCount;
uint32_t minPositionTruncateBitCount;
safe_VkClusterAccelerationStructureTriangleClusterInputNV(const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkClusterAccelerationStructureTriangleClusterInputNV(
const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src);
safe_VkClusterAccelerationStructureTriangleClusterInputNV& operator=(
const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src);
safe_VkClusterAccelerationStructureTriangleClusterInputNV();
~safe_VkClusterAccelerationStructureTriangleClusterInputNV();
void initialize(const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureTriangleClusterInputNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureTriangleClusterInputNV* ptr() {
return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV*>(this);
}
VkClusterAccelerationStructureTriangleClusterInputNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV const*>(this);
}
};
struct safe_VkClusterAccelerationStructureMoveObjectsInputNV {
VkStructureType sType;
void* pNext{};
VkClusterAccelerationStructureTypeNV type;
VkBool32 noMoveOverlap;
VkDeviceSize maxMovedBytes;
safe_VkClusterAccelerationStructureMoveObjectsInputNV(const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkClusterAccelerationStructureMoveObjectsInputNV(const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src);
safe_VkClusterAccelerationStructureMoveObjectsInputNV& operator=(
const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src);
safe_VkClusterAccelerationStructureMoveObjectsInputNV();
~safe_VkClusterAccelerationStructureMoveObjectsInputNV();
void initialize(const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureMoveObjectsInputNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureMoveObjectsInputNV* ptr() {
return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV*>(this);
}
VkClusterAccelerationStructureMoveObjectsInputNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV const*>(this);
}
};
union safe_VkClusterAccelerationStructureOpInputNV {
safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel;
safe_VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters;
safe_VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects;
safe_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV* in_struct,
PNextCopyState* copy_state = {});
safe_VkClusterAccelerationStructureOpInputNV(const safe_VkClusterAccelerationStructureOpInputNV& copy_src);
safe_VkClusterAccelerationStructureOpInputNV& operator=(const safe_VkClusterAccelerationStructureOpInputNV& copy_src);
safe_VkClusterAccelerationStructureOpInputNV();
~safe_VkClusterAccelerationStructureOpInputNV();
void initialize(const VkClusterAccelerationStructureOpInputNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureOpInputNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureOpInputNV* ptr() { return reinterpret_cast<VkClusterAccelerationStructureOpInputNV*>(this); }
VkClusterAccelerationStructureOpInputNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureOpInputNV const*>(this);
}
};
struct safe_VkClusterAccelerationStructureInputInfoNV {
VkStructureType sType;
void* pNext{};
uint32_t maxAccelerationStructureCount;
VkBuildAccelerationStructureFlagsKHR flags;
VkClusterAccelerationStructureOpTypeNV opType;
VkClusterAccelerationStructureOpModeNV opMode;
safe_VkClusterAccelerationStructureOpInputNV opInput;
safe_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkClusterAccelerationStructureInputInfoNV(const safe_VkClusterAccelerationStructureInputInfoNV& copy_src);
safe_VkClusterAccelerationStructureInputInfoNV& operator=(const safe_VkClusterAccelerationStructureInputInfoNV& copy_src);
safe_VkClusterAccelerationStructureInputInfoNV();
~safe_VkClusterAccelerationStructureInputInfoNV();
void initialize(const VkClusterAccelerationStructureInputInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureInputInfoNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureInputInfoNV* ptr() { return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV*>(this); }
VkClusterAccelerationStructureInputInfoNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV const*>(this);
}
};
struct safe_VkClusterAccelerationStructureCommandsInfoNV {
VkStructureType sType;
void* pNext{};
safe_VkClusterAccelerationStructureInputInfoNV input;
VkDeviceAddress dstImplicitData;
VkDeviceAddress scratchData;
VkStridedDeviceAddressRegionKHR dstAddressesArray;
VkStridedDeviceAddressRegionKHR dstSizesArray;
VkStridedDeviceAddressRegionKHR srcInfosArray;
VkDeviceAddress srcInfosCount;
VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags;
safe_VkClusterAccelerationStructureCommandsInfoNV(const VkClusterAccelerationStructureCommandsInfoNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkClusterAccelerationStructureCommandsInfoNV(const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src);
safe_VkClusterAccelerationStructureCommandsInfoNV& operator=(const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src);
safe_VkClusterAccelerationStructureCommandsInfoNV();
~safe_VkClusterAccelerationStructureCommandsInfoNV();
void initialize(const VkClusterAccelerationStructureCommandsInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkClusterAccelerationStructureCommandsInfoNV* copy_src, PNextCopyState* copy_state = {});
VkClusterAccelerationStructureCommandsInfoNV* ptr() {
return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV*>(this);
}
VkClusterAccelerationStructureCommandsInfoNV const* ptr() const {
return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV const*>(this);
}
};
struct safe_VkAccelerationStructureBuildSizesInfoKHR {
VkStructureType sType;
const void* pNext{};
VkDeviceSize accelerationStructureSize;
VkDeviceSize updateScratchSize;
VkDeviceSize buildScratchSize;
safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
safe_VkAccelerationStructureBuildSizesInfoKHR();
~safe_VkAccelerationStructureBuildSizesInfoKHR();
void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
}
};
struct safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
VkStructureType sType;
void* pNext{};
VkBool32 allowClusterAccelerationStructure;
safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src);
safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& operator=(
const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src);
safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV();
~safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV();
void initialize(const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* copy_src,
PNextCopyState* copy_state = {});
VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* ptr() {
return reinterpret_cast<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(this);
}
VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const* ptr() const {
return reinterpret_cast<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const*>(this);
}
};
struct safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
VkStructureType sType;
void* pNext{};
VkBool32 partitionedAccelerationStructure;
safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src);
safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& operator=(
const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src);
safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV();
~safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV();
void initialize(const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* copy_src,
PNextCopyState* copy_state = {});
VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* ptr() {
return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(this);
}
VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const*>(this);
}
};
struct safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
VkStructureType sType;
void* pNext{};
uint32_t maxPartitionCount;
safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src);
safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& operator=(
const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src);
safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV();
~safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV();
void initialize(const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* copy_src,
PNextCopyState* copy_state = {});
VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* ptr() {
return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(this);
}
VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const*>(this);
}
};
struct safe_VkPartitionedAccelerationStructureFlagsNV {
VkStructureType sType;
void* pNext{};
VkBool32 enablePartitionTranslation;
safe_VkPartitionedAccelerationStructureFlagsNV(const VkPartitionedAccelerationStructureFlagsNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPartitionedAccelerationStructureFlagsNV(const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src);
safe_VkPartitionedAccelerationStructureFlagsNV& operator=(const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src);
safe_VkPartitionedAccelerationStructureFlagsNV();
~safe_VkPartitionedAccelerationStructureFlagsNV();
void initialize(const VkPartitionedAccelerationStructureFlagsNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPartitionedAccelerationStructureFlagsNV* copy_src, PNextCopyState* copy_state = {});
VkPartitionedAccelerationStructureFlagsNV* ptr() { return reinterpret_cast<VkPartitionedAccelerationStructureFlagsNV*>(this); }
VkPartitionedAccelerationStructureFlagsNV const* ptr() const {
return reinterpret_cast<VkPartitionedAccelerationStructureFlagsNV const*>(this);
}
};
struct safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV {
VkStructureType sType;
void* pNext{};
uint32_t accelerationStructureCount;
const VkDeviceAddress* pAccelerationStructures{};
safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src);
safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& operator=(
const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src);
safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV();
~safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV();
void initialize(const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV* copy_src, PNextCopyState* copy_state = {});
VkWriteDescriptorSetPartitionedAccelerationStructureNV* ptr() {
return reinterpret_cast<VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(this);
}
VkWriteDescriptorSetPartitionedAccelerationStructureNV const* ptr() const {
return reinterpret_cast<VkWriteDescriptorSetPartitionedAccelerationStructureNV const*>(this);
}
};
struct safe_VkPartitionedAccelerationStructureInstancesInputNV {
VkStructureType sType;
void* pNext{};
VkBuildAccelerationStructureFlagsKHR flags;
uint32_t instanceCount;
uint32_t maxInstancePerPartitionCount;
uint32_t partitionCount;
uint32_t maxInstanceInGlobalPartitionCount;
safe_VkPartitionedAccelerationStructureInstancesInputNV(const VkPartitionedAccelerationStructureInstancesInputNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPartitionedAccelerationStructureInstancesInputNV(
const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src);
safe_VkPartitionedAccelerationStructureInstancesInputNV& operator=(
const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src);
safe_VkPartitionedAccelerationStructureInstancesInputNV();
~safe_VkPartitionedAccelerationStructureInstancesInputNV();
void initialize(const VkPartitionedAccelerationStructureInstancesInputNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPartitionedAccelerationStructureInstancesInputNV* copy_src, PNextCopyState* copy_state = {});
VkPartitionedAccelerationStructureInstancesInputNV* ptr() {
return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV*>(this);
}
VkPartitionedAccelerationStructureInstancesInputNV const* ptr() const {
return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV const*>(this);
}
};
struct safe_VkBuildPartitionedAccelerationStructureInfoNV {
VkStructureType sType;
void* pNext{};
safe_VkPartitionedAccelerationStructureInstancesInputNV input;
VkDeviceAddress srcAccelerationStructureData;
VkDeviceAddress dstAccelerationStructureData;
VkDeviceAddress scratchData;
VkDeviceAddress srcInfos;
VkDeviceAddress srcInfosCount;
safe_VkBuildPartitionedAccelerationStructureInfoNV(const VkBuildPartitionedAccelerationStructureInfoNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkBuildPartitionedAccelerationStructureInfoNV(const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src);
safe_VkBuildPartitionedAccelerationStructureInfoNV& operator=(
const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src);
safe_VkBuildPartitionedAccelerationStructureInfoNV();
~safe_VkBuildPartitionedAccelerationStructureInfoNV();
void initialize(const VkBuildPartitionedAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkBuildPartitionedAccelerationStructureInfoNV* copy_src, PNextCopyState* copy_state = {});
VkBuildPartitionedAccelerationStructureInfoNV* ptr() {
return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV*>(this);
}
VkBuildPartitionedAccelerationStructureInfoNV const* ptr() const {
return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV const*>(this);
}
};
struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
VkStructureType sType;
void* pNext{};
@ -20052,26 +20614,6 @@ struct safe_VkCopyAccelerationStructureInfoKHR {
return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const*>(this);
}
};
struct safe_VkAccelerationStructureBuildSizesInfoKHR {
VkStructureType sType;
const void* pNext{};
VkDeviceSize accelerationStructureSize;
VkDeviceSize updateScratchSize;
VkDeviceSize buildScratchSize;
safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
safe_VkAccelerationStructureBuildSizesInfoKHR();
~safe_VkAccelerationStructureBuildSizesInfoKHR();
void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
}
};
struct safe_VkRayTracingShaderGroupCreateInfoKHR {
VkStructureType sType;
const void* pNext{};

23
include/vulkan/utility/vk_struct_helper.hpp
View file

@ -905,6 +905,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMemoryDecompressionP
template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkComputePipelineIndirectBufferInfoNV>() { return VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; }
template <> inline VkStructureType GetSType<VkPipelineIndirectDeviceAddressInfoNV>() { return VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryLinearSweptSpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; }
template <> inline VkStructureType GetSType<VkAccelerationStructureGeometrySpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkImageViewSampleWeightCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; }
@ -951,6 +954,10 @@ template <> inline VkStructureType GetSType<VkAmigoProfilingSubmitInfoSEC>() { r
template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkConvertCooperativeVectorMatrixInfoNV>() { return VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; }
@ -998,6 +1005,21 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInherit
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkClusterAccelerationStructureClustersBottomLevelInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; }
template <> inline VkStructureType GetSType<VkClusterAccelerationStructureTriangleClusterInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; }
template <> inline VkStructureType GetSType<VkClusterAccelerationStructureMoveObjectsInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; }
template <> inline VkStructureType GetSType<VkClusterAccelerationStructureInputInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; }
template <> inline VkStructureType GetSType<VkClusterAccelerationStructureCommandsInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; }
template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
template <> inline VkStructureType GetSType<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureFlagsNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; }
template <> inline VkStructureType GetSType<VkWriteDescriptorSetPartitionedAccelerationStructureNV>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; }
template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureInstancesInputNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; }
template <> inline VkStructureType GetSType<VkBuildPartitionedAccelerationStructureInfoNV>() { return VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; }
template <> inline VkStructureType GetSType<VkGeneratedCommandsMemoryRequirementsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; }
@ -1043,7 +1065,6 @@ template <> inline VkStructureType GetSType<VkAccelerationStructureVersionInfoKH
template <> inline VkStructureType GetSType<VkCopyAccelerationStructureToMemoryInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; }
template <> inline VkStructureType GetSType<VkCopyMemoryToAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkCopyAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
template <> inline VkStructureType GetSType<VkRayTracingShaderGroupCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkRayTracingPipelineInterfaceCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkRayTracingPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; }

298
include/vulkan/vk_enum_string_helper.h
View file

@ -1722,6 +1722,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV";
case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
return "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV";
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV";
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
@ -1836,6 +1842,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
return "VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
@ -2014,6 +2028,34 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV";
case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV";
case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV";
case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV";
case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV";
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV";
case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
return "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV";
case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
return "VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV";
case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
return "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
@ -3504,6 +3546,8 @@ static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
return "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM";
case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
return "VK_DESCRIPTOR_TYPE_MUTABLE_EXT";
case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV:
return "VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV";
default:
return "Unhandled VkDescriptorType";
}
@ -4006,6 +4050,14 @@ static inline const char* string_VkComponentTypeKHR(VkComponentTypeKHR input_val
return "VK_COMPONENT_TYPE_UINT32_KHR";
case VK_COMPONENT_TYPE_UINT64_KHR:
return "VK_COMPONENT_TYPE_UINT64_KHR";
case VK_COMPONENT_TYPE_SINT8_PACKED_NV:
return "VK_COMPONENT_TYPE_SINT8_PACKED_NV";
case VK_COMPONENT_TYPE_UINT8_PACKED_NV:
return "VK_COMPONENT_TYPE_UINT8_PACKED_NV";
case VK_COMPONENT_TYPE_FLOAT_E4M3_NV:
return "VK_COMPONENT_TYPE_FLOAT_E4M3_NV";
case VK_COMPONENT_TYPE_FLOAT_E5M2_NV:
return "VK_COMPONENT_TYPE_FLOAT_E5M2_NV";
default:
return "Unhandled VkComponentTypeKHR";
}
@ -4370,6 +4422,10 @@ static inline const char* string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value
return "VK_GEOMETRY_TYPE_AABBS_KHR";
case VK_GEOMETRY_TYPE_INSTANCES_KHR:
return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
case VK_GEOMETRY_TYPE_SPHERES_NV:
return "VK_GEOMETRY_TYPE_SPHERES_NV";
case VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV:
return "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV";
default:
return "Unhandled VkGeometryTypeKHR";
}
@ -4750,6 +4806,8 @@ static inline const char* string_VkOpacityMicromapSpecialIndexEXT(VkOpacityMicro
return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT";
case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT:
return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT";
case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV:
return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV";
default:
return "Unhandled VkOpacityMicromapSpecialIndexEXT";
}
@ -4790,6 +4848,26 @@ static inline const char* string_VkDisplacementMicromapFormatNV(VkDisplacementMi
}
}
#endif // VK_ENABLE_BETA_EXTENSIONS
static inline const char* string_VkRayTracingLssIndexingModeNV(VkRayTracingLssIndexingModeNV input_value) {
switch (input_value) {
case VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV:
return "VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV";
case VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV:
return "VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV";
default:
return "Unhandled VkRayTracingLssIndexingModeNV";
}
}
static inline const char* string_VkRayTracingLssPrimitiveEndCapsModeNV(VkRayTracingLssPrimitiveEndCapsModeNV input_value) {
switch (input_value) {
case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV:
return "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV";
case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV:
return "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV";
default:
return "Unhandled VkRayTracingLssPrimitiveEndCapsModeNV";
}
}
static inline const char* string_VkSubpassMergeStatusEXT(VkSubpassMergeStatusEXT input_value) {
switch (input_value) {
case VK_SUBPASS_MERGE_STATUS_MERGED_EXT:
@ -4924,6 +5002,20 @@ static inline const char* string_VkRayTracingInvocationReorderModeNV(VkRayTracin
return "Unhandled VkRayTracingInvocationReorderModeNV";
}
}
static inline const char* string_VkCooperativeVectorMatrixLayoutNV(VkCooperativeVectorMatrixLayoutNV input_value) {
switch (input_value) {
case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV:
return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV";
case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV:
return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV";
case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV:
return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV";
case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV:
return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV";
default:
return "Unhandled VkCooperativeVectorMatrixLayoutNV";
}
}
static inline const char* string_VkLayerSettingTypeEXT(VkLayerSettingTypeEXT input_value) {
switch (input_value) {
case VK_LAYER_SETTING_TYPE_BOOL32_EXT:
@ -5034,6 +5126,58 @@ static inline const char* string_VkDisplaySurfaceStereoTypeNV(VkDisplaySurfaceSt
return "Unhandled VkDisplaySurfaceStereoTypeNV";
}
}
static inline const char* string_VkClusterAccelerationStructureTypeNV(VkClusterAccelerationStructureTypeNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV";
default:
return "Unhandled VkClusterAccelerationStructureTypeNV";
}
}
static inline const char* string_VkClusterAccelerationStructureOpTypeNV(VkClusterAccelerationStructureOpTypeNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV";
default:
return "Unhandled VkClusterAccelerationStructureOpTypeNV";
}
}
static inline const char* string_VkClusterAccelerationStructureOpModeNV(VkClusterAccelerationStructureOpModeNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV";
default:
return "Unhandled VkClusterAccelerationStructureOpModeNV";
}
}
static inline const char* string_VkPartitionedAccelerationStructureOpTypeNV(VkPartitionedAccelerationStructureOpTypeNV input_value) {
switch (input_value) {
case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV";
default:
return "Unhandled VkPartitionedAccelerationStructureOpTypeNV";
}
}
static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) {
switch (input_value) {
case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
@ -7385,6 +7529,7 @@ static inline const char* string_VkPipelineStageFlagBits2(uint64_t input_value)
if (input_value == VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT) return "VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT";
if (input_value == VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI) return "VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI";
if (input_value == VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV) return "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV";
if (input_value == VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV) return "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV";
return "Unhandled VkPipelineStageFlagBits2";
}
@ -7561,6 +7706,7 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
if (input_value == VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV) return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV";
if (input_value == VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM";
if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM";
@ -7628,6 +7774,7 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value)
#ifdef VK_ENABLE_BETA_EXTENSIONS
if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
#endif // VK_ENABLE_BETA_EXTENSIONS
if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV";
if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR";
@ -9885,6 +10032,157 @@ static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT i
return ret;
}
#endif // __cplusplus
static inline const char* string_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(VkClusterAccelerationStructureAddressResolutionFlagBitsNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV";
default:
return "Unhandled VkClusterAccelerationStructureAddressResolutionFlagBitsNV";
}
}
#ifdef __cplusplus
static inline std::string string_VkClusterAccelerationStructureAddressResolutionFlagsNV(VkClusterAccelerationStructureAddressResolutionFlagsNV input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(static_cast<VkClusterAccelerationStructureAddressResolutionFlagBitsNV>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkClusterAccelerationStructureAddressResolutionFlagsNV(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkClusterAccelerationStructureClusterFlagBitsNV(VkClusterAccelerationStructureClusterFlagBitsNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV";
default:
return "Unhandled VkClusterAccelerationStructureClusterFlagBitsNV";
}
}
#ifdef __cplusplus
static inline std::string string_VkClusterAccelerationStructureClusterFlagsNV(VkClusterAccelerationStructureClusterFlagsNV input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkClusterAccelerationStructureClusterFlagBitsNV(static_cast<VkClusterAccelerationStructureClusterFlagBitsNV>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkClusterAccelerationStructureClusterFlagsNV(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkClusterAccelerationStructureGeometryFlagBitsNV(VkClusterAccelerationStructureGeometryFlagBitsNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV";
default:
return "Unhandled VkClusterAccelerationStructureGeometryFlagBitsNV";
}
}
#ifdef __cplusplus
static inline std::string string_VkClusterAccelerationStructureGeometryFlagsNV(VkClusterAccelerationStructureGeometryFlagsNV input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkClusterAccelerationStructureGeometryFlagBitsNV(static_cast<VkClusterAccelerationStructureGeometryFlagBitsNV>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkClusterAccelerationStructureGeometryFlagsNV(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkClusterAccelerationStructureIndexFormatFlagBitsNV(VkClusterAccelerationStructureIndexFormatFlagBitsNV input_value) {
switch (input_value) {
case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV";
case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV:
return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV";
default:
return "Unhandled VkClusterAccelerationStructureIndexFormatFlagBitsNV";
}
}
#ifdef __cplusplus
static inline std::string string_VkClusterAccelerationStructureIndexFormatFlagsNV(VkClusterAccelerationStructureIndexFormatFlagsNV input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkClusterAccelerationStructureIndexFormatFlagBitsNV(static_cast<VkClusterAccelerationStructureIndexFormatFlagBitsNV>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkClusterAccelerationStructureIndexFormatFlagsNV(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkPartitionedAccelerationStructureInstanceFlagBitsNV(VkPartitionedAccelerationStructureInstanceFlagBitsNV input_value) {
switch (input_value) {
case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV";
case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV:
return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV";
default:
return "Unhandled VkPartitionedAccelerationStructureInstanceFlagBitsNV";
}
}
#ifdef __cplusplus
static inline std::string string_VkPartitionedAccelerationStructureInstanceFlagsNV(VkPartitionedAccelerationStructureInstanceFlagsNV input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkPartitionedAccelerationStructureInstanceFlagBitsNV(static_cast<VkPartitionedAccelerationStructureInstanceFlagBitsNV>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkPartitionedAccelerationStructureInstanceFlagsNV(0)");
return ret;
}
#endif // __cplusplus
static inline const char* string_VkIndirectCommandsInputModeFlagBitsEXT(VkIndirectCommandsInputModeFlagBitsEXT input_value) {
switch (input_value) {
case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT:

44
scripts/generators/safe_struct_generator.py
View file

@ -1,10 +1,10 @@
#!/usr/bin/python3 -i
#
# Copyright (c) 2015-2024 The Khronos Group Inc.
# Copyright (c) 2015-2024 Valve Corporation
# Copyright (c) 2015-2024 LunarG, Inc.
# Copyright (c) 2015-2024 Google Inc.
# Copyright (c) 2023-2024 RasterGrid Kft.
# Copyright (c) 2015-2025 The Khronos Group Inc.
# Copyright (c) 2015-2025 Valve Corporation
# Copyright (c) 2015-2025 LunarG, Inc.
# Copyright (c) 2015-2025 Google Inc.
# Copyright (c) 2023-2025 RasterGrid Kft.
#
# SPDX-License-Identifier: Apache-2.0
@ -139,10 +139,10 @@ class SafeStructOutputGenerator(BaseGenerator):
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
@ -726,21 +726,13 @@ void FreePnextChain(const void *pNext) {
safe_name = self.convertName(struct.name)
if struct.union:
if struct.name in self.union_of_pointers:
default_init_list = ' type_at_end {0},'
out.append(f'''
{safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param})
{{
{copy_pnext + construct_txt}}}
''')
else:
# Unions don't allow multiple members in the initialization list, so just call initialize
out.append(f'''
{safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
{{
initialize(in_struct);
}}
''')
# Unions don't allow multiple members in the initialization list, so just call initialize
out.append(f'''
{safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
{{
initialize(in_struct);
}}
''')
else:
out.append(f'''
{safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) :{init_list}
@ -748,7 +740,11 @@ void FreePnextChain(const void *pNext) {
{copy_pnext_if + construct_txt}}}
''')
if '' != default_init_list:
# trim trailing comma from initializer list
default_init_list = f' :{default_init_list[:-1]}'
# truncate union initializer list to first element
if struct.union:
default_init_list = default_init_list.split(',')[0]
default_init_body = '\n' + custom_defeault_construct_txt[struct.name] if struct.name in custom_defeault_construct_txt else ''
out.append(f'''
{safe_name}::{safe_name}(){default_init_list}

2
scripts/known_good.json
View file

@ -7,7 +7,7 @@
"sub_dir": "Vulkan-Headers",
"build_dir": "Vulkan-Headers/build",
"install_dir": "Vulkan-Headers/build/install",
"commit": "v1.4.306"
"commit": "v1.4.307"
},
{
"name": "googletest",

8
src/vulkan/vk_safe_struct_core.cpp
View file

@ -3,10 +3,10 @@
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*

8
src/vulkan/vk_safe_struct_ext.cpp
View file

@ -3,10 +3,10 @@
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*

134
src/vulkan/vk_safe_struct_khr.cpp
View file

@ -3,10 +3,10 @@
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
@ -15242,6 +15242,69 @@ void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressK
hostAddress = copy_src->hostAddress;
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
accelerationStructureSize(in_struct->accelerationStructureSize),
updateScratchSize(in_struct->updateScratchSize),
buildScratchSize(in_struct->buildScratchSize) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
: sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
pNext(nullptr),
accelerationStructureSize(),
updateScratchSize(),
buildScratchSize() {}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
accelerationStructureSize = in_struct->accelerationStructureSize;
updateScratchSize = in_struct->updateScratchSize;
buildScratchSize = in_struct->buildScratchSize;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
accelerationStructureSize = copy_src->accelerationStructureSize;
updateScratchSize = copy_src->updateScratchSize;
buildScratchSize = copy_src->buildScratchSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
@ -16076,69 +16139,6 @@ void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccele
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
accelerationStructureSize(in_struct->accelerationStructureSize),
updateScratchSize(in_struct->updateScratchSize),
buildScratchSize(in_struct->buildScratchSize) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
: sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
pNext(nullptr),
accelerationStructureSize(),
updateScratchSize(),
buildScratchSize() {}
safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
accelerationStructureSize = copy_src.accelerationStructureSize;
updateScratchSize = copy_src.updateScratchSize;
buildScratchSize = copy_src.buildScratchSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
accelerationStructureSize = in_struct->accelerationStructureSize;
updateScratchSize = in_struct->updateScratchSize;
buildScratchSize = in_struct->buildScratchSize;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
accelerationStructureSize = copy_src->accelerationStructureSize;
updateScratchSize = copy_src->updateScratchSize;
buildScratchSize = copy_src->buildScratchSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
const VkRayTracingShaderGroupCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),

68
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -3,10 +3,10 @@
/***************************************************************************
*
* Copyright (c) 2015-2024 The Khronos Group Inc.
* Copyright (c) 2015-2024 Valve Corporation
* Copyright (c) 2015-2024 LunarG, Inc.
* Copyright (c) 2015-2024 Google Inc.
* Copyright (c) 2015-2025 The Khronos Group Inc.
* Copyright (c) 2015-2025 Valve Corporation
* Copyright (c) 2015-2025 LunarG, Inc.
* Copyright (c) 2015-2025 Google Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
@ -1716,6 +1716,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
safe_pNext = new safe_VkComputePipelineIndirectBufferInfoNV(reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext), copy_state, false);
break;
@ -1823,6 +1826,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(pNext), copy_state, false);
break;
@ -1939,6 +1948,27 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
safe_pNext = new safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
safe_pNext = new safe_VkPartitionedAccelerationStructureFlagsNV(reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
safe_pNext = new safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(pNext), copy_state, false);
break;
@ -3721,6 +3751,9 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
delete reinterpret_cast<safe_VkComputePipelineIndirectBufferInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
break;
@ -3828,6 +3861,12 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeVectorPropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeVectorFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
break;
@ -3944,6 +3983,27 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
delete reinterpret_cast<safe_VkPartitionedAccelerationStructureFlagsNV *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
delete reinterpret_cast<safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(header);
break;

1699
src/vulkan/vk_safe_struct_vendor.cpp
View file

File diff suppressed because it is too large Load diff