eden-emu/Vulkan-Utility-Libraries
19
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

build: Update to header 1.4.312

Browse source
This commit is contained in:
Mike Schuchardt 2025-04-04 09:19:02 -07:00
parent 551221d913
commit 01851ecae5
7 changed files with 866 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -641,6 +641,9 @@ typedef struct VkuDeviceDispatchTable_ {
PFN_vkDestroyCudaFunctionNV DestroyCudaFunctionNV;
PFN_vkCmdCudaLaunchKernelNV CmdCudaLaunchKernelNV;
#endif // VK_ENABLE_BETA_EXTENSIONS
PFN_vkCmdDispatchTileQCOM CmdDispatchTileQCOM;
PFN_vkCmdBeginPerTileExecutionQCOM CmdBeginPerTileExecutionQCOM;
PFN_vkCmdEndPerTileExecutionQCOM CmdEndPerTileExecutionQCOM;
#ifdef VK_USE_PLATFORM_METAL_EXT
PFN_vkExportMetalObjectsEXT ExportMetalObjectsEXT;
#endif // VK_USE_PLATFORM_METAL_EXT
@ -764,6 +767,9 @@ typedef struct VkuDeviceDispatchTable_ {
#ifdef VK_USE_PLATFORM_SCREEN_QNX
PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
#endif // VK_USE_PLATFORM_SCREEN_QNX
PFN_vkCreateExternalComputeQueueNV CreateExternalComputeQueueNV;
PFN_vkDestroyExternalComputeQueueNV DestroyExternalComputeQueueNV;
PFN_vkGetExternalComputeQueueDataNV GetExternalComputeQueueDataNV;
PFN_vkGetClusterAccelerationStructureBuildSizesNV GetClusterAccelerationStructureBuildSizesNV;
PFN_vkCmdBuildClusterAccelerationStructureIndirectNV CmdBuildClusterAccelerationStructureIndirectNV;
PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV GetPartitionedAccelerationStructuresBuildSizesNV;
@ -1286,6 +1292,9 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
table->DestroyCudaFunctionNV = (PFN_vkDestroyCudaFunctionNV)gdpa(device, "vkDestroyCudaFunctionNV");
table->CmdCudaLaunchKernelNV = (PFN_vkCmdCudaLaunchKernelNV)gdpa(device, "vkCmdCudaLaunchKernelNV");
#endif // VK_ENABLE_BETA_EXTENSIONS
table->CmdDispatchTileQCOM = (PFN_vkCmdDispatchTileQCOM)gdpa(device, "vkCmdDispatchTileQCOM");
table->CmdBeginPerTileExecutionQCOM = (PFN_vkCmdBeginPerTileExecutionQCOM)gdpa(device, "vkCmdBeginPerTileExecutionQCOM");
table->CmdEndPerTileExecutionQCOM = (PFN_vkCmdEndPerTileExecutionQCOM)gdpa(device, "vkCmdEndPerTileExecutionQCOM");
#ifdef VK_USE_PLATFORM_METAL_EXT
table->ExportMetalObjectsEXT = (PFN_vkExportMetalObjectsEXT)gdpa(device, "vkExportMetalObjectsEXT");
#endif // VK_USE_PLATFORM_METAL_EXT
@ -1409,6 +1418,9 @@ 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->CreateExternalComputeQueueNV = (PFN_vkCreateExternalComputeQueueNV)gdpa(device, "vkCreateExternalComputeQueueNV");
table->DestroyExternalComputeQueueNV = (PFN_vkDestroyExternalComputeQueueNV)gdpa(device, "vkDestroyExternalComputeQueueNV");
table->GetExternalComputeQueueDataNV = (PFN_vkGetExternalComputeQueueDataNV)gdpa(device, "vkGetExternalComputeQueueDataNV");
table->GetClusterAccelerationStructureBuildSizesNV = (PFN_vkGetClusterAccelerationStructureBuildSizesNV)gdpa(device, "vkGetClusterAccelerationStructureBuildSizesNV");
table->CmdBuildClusterAccelerationStructureIndirectNV = (PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)gdpa(device, "vkCmdBuildClusterAccelerationStructureIndirectNV");
table->GetPartitionedAccelerationStructuresBuildSizesNV = (PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)gdpa(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV");

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

@ -14231,6 +14231,119 @@ struct safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
}
};
#endif // VK_ENABLE_BETA_EXTENSIONS
struct safe_VkPhysicalDeviceTileShadingFeaturesQCOM {
VkStructureType sType;
void* pNext{};
VkBool32 tileShading;
VkBool32 tileShadingFragmentStage;
VkBool32 tileShadingColorAttachments;
VkBool32 tileShadingDepthAttachments;
VkBool32 tileShadingStencilAttachments;
VkBool32 tileShadingInputAttachments;
VkBool32 tileShadingSampledAttachments;
VkBool32 tileShadingPerTileDraw;
VkBool32 tileShadingPerTileDispatch;
VkBool32 tileShadingDispatchTile;
VkBool32 tileShadingApron;
VkBool32 tileShadingAnisotropicApron;
VkBool32 tileShadingAtomicOps;
VkBool32 tileShadingImageProcessing;
safe_VkPhysicalDeviceTileShadingFeaturesQCOM(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceTileShadingFeaturesQCOM(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src);
safe_VkPhysicalDeviceTileShadingFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src);
safe_VkPhysicalDeviceTileShadingFeaturesQCOM();
~safe_VkPhysicalDeviceTileShadingFeaturesQCOM();
void initialize(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceTileShadingFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(this); }
VkPhysicalDeviceTileShadingFeaturesQCOM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTileShadingFeaturesQCOM const*>(this);
}
};
struct safe_VkPhysicalDeviceTileShadingPropertiesQCOM {
VkStructureType sType;
void* pNext{};
uint32_t maxApronSize;
VkBool32 preferNonCoherent;
VkExtent2D tileGranularity;
VkExtent2D maxTileShadingRate;
safe_VkPhysicalDeviceTileShadingPropertiesQCOM(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceTileShadingPropertiesQCOM(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src);
safe_VkPhysicalDeviceTileShadingPropertiesQCOM& operator=(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src);
safe_VkPhysicalDeviceTileShadingPropertiesQCOM();
~safe_VkPhysicalDeviceTileShadingPropertiesQCOM();
void initialize(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceTileShadingPropertiesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceTileShadingPropertiesQCOM*>(this); }
VkPhysicalDeviceTileShadingPropertiesQCOM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTileShadingPropertiesQCOM const*>(this);
}
};
struct safe_VkRenderPassTileShadingCreateInfoQCOM {
VkStructureType sType;
const void* pNext{};
VkTileShadingRenderPassFlagsQCOM flags;
VkExtent2D tileApronSize;
safe_VkRenderPassTileShadingCreateInfoQCOM(const VkRenderPassTileShadingCreateInfoQCOM* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkRenderPassTileShadingCreateInfoQCOM(const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src);
safe_VkRenderPassTileShadingCreateInfoQCOM& operator=(const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src);
safe_VkRenderPassTileShadingCreateInfoQCOM();
~safe_VkRenderPassTileShadingCreateInfoQCOM();
void initialize(const VkRenderPassTileShadingCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkRenderPassTileShadingCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkRenderPassTileShadingCreateInfoQCOM* ptr() { return reinterpret_cast<VkRenderPassTileShadingCreateInfoQCOM*>(this); }
VkRenderPassTileShadingCreateInfoQCOM const* ptr() const {
return reinterpret_cast<VkRenderPassTileShadingCreateInfoQCOM const*>(this);
}
};
struct safe_VkPerTileBeginInfoQCOM {
VkStructureType sType;
const void* pNext{};
safe_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPerTileBeginInfoQCOM(const safe_VkPerTileBeginInfoQCOM& copy_src);
safe_VkPerTileBeginInfoQCOM& operator=(const safe_VkPerTileBeginInfoQCOM& copy_src);
safe_VkPerTileBeginInfoQCOM();
~safe_VkPerTileBeginInfoQCOM();
void initialize(const VkPerTileBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPerTileBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkPerTileBeginInfoQCOM* ptr() { return reinterpret_cast<VkPerTileBeginInfoQCOM*>(this); }
VkPerTileBeginInfoQCOM const* ptr() const { return reinterpret_cast<VkPerTileBeginInfoQCOM const*>(this); }
};
struct safe_VkPerTileEndInfoQCOM {
VkStructureType sType;
const void* pNext{};
safe_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPerTileEndInfoQCOM(const safe_VkPerTileEndInfoQCOM& copy_src);
safe_VkPerTileEndInfoQCOM& operator=(const safe_VkPerTileEndInfoQCOM& copy_src);
safe_VkPerTileEndInfoQCOM();
~safe_VkPerTileEndInfoQCOM();
void initialize(const VkPerTileEndInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPerTileEndInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkPerTileEndInfoQCOM* ptr() { return reinterpret_cast<VkPerTileEndInfoQCOM*>(this); }
VkPerTileEndInfoQCOM const* ptr() const { return reinterpret_cast<VkPerTileEndInfoQCOM const*>(this); }
};
struct safe_VkDispatchTileInfoQCOM {
VkStructureType sType;
const void* pNext{};
safe_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkDispatchTileInfoQCOM(const safe_VkDispatchTileInfoQCOM& copy_src);
safe_VkDispatchTileInfoQCOM& operator=(const safe_VkDispatchTileInfoQCOM& copy_src);
safe_VkDispatchTileInfoQCOM();
~safe_VkDispatchTileInfoQCOM();
void initialize(const VkDispatchTileInfoQCOM* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkDispatchTileInfoQCOM* copy_src, PNextCopyState* copy_state = {});
VkDispatchTileInfoQCOM* ptr() { return reinterpret_cast<VkDispatchTileInfoQCOM*>(this); }
VkDispatchTileInfoQCOM const* ptr() const { return reinterpret_cast<VkDispatchTileInfoQCOM const*>(this); }
};
struct safe_VkQueryLowLatencySupportNV {
VkStructureType sType;
const void* pNext{};
@ -19233,6 +19346,82 @@ struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV const*>(this);
}
};
struct safe_VkExternalComputeQueueDeviceCreateInfoNV {
VkStructureType sType;
const void* pNext{};
uint32_t reservedExternalQueues;
safe_VkExternalComputeQueueDeviceCreateInfoNV(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkExternalComputeQueueDeviceCreateInfoNV(const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src);
safe_VkExternalComputeQueueDeviceCreateInfoNV& operator=(const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src);
safe_VkExternalComputeQueueDeviceCreateInfoNV();
~safe_VkExternalComputeQueueDeviceCreateInfoNV();
void initialize(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkExternalComputeQueueDeviceCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
VkExternalComputeQueueDeviceCreateInfoNV* ptr() { return reinterpret_cast<VkExternalComputeQueueDeviceCreateInfoNV*>(this); }
VkExternalComputeQueueDeviceCreateInfoNV const* ptr() const {
return reinterpret_cast<VkExternalComputeQueueDeviceCreateInfoNV const*>(this);
}
};
struct safe_VkExternalComputeQueueCreateInfoNV {
VkStructureType sType;
const void* pNext{};
VkQueue preferredQueue;
safe_VkExternalComputeQueueCreateInfoNV(const VkExternalComputeQueueCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkExternalComputeQueueCreateInfoNV(const safe_VkExternalComputeQueueCreateInfoNV& copy_src);
safe_VkExternalComputeQueueCreateInfoNV& operator=(const safe_VkExternalComputeQueueCreateInfoNV& copy_src);
safe_VkExternalComputeQueueCreateInfoNV();
~safe_VkExternalComputeQueueCreateInfoNV();
void initialize(const VkExternalComputeQueueCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkExternalComputeQueueCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
VkExternalComputeQueueCreateInfoNV* ptr() { return reinterpret_cast<VkExternalComputeQueueCreateInfoNV*>(this); }
VkExternalComputeQueueCreateInfoNV const* ptr() const {
return reinterpret_cast<VkExternalComputeQueueCreateInfoNV const*>(this);
}
};
struct safe_VkExternalComputeQueueDataParamsNV {
VkStructureType sType;
const void* pNext{};
uint32_t deviceIndex;
safe_VkExternalComputeQueueDataParamsNV(const VkExternalComputeQueueDataParamsNV* in_struct, PNextCopyState* copy_state = {},
bool copy_pnext = true);
safe_VkExternalComputeQueueDataParamsNV(const safe_VkExternalComputeQueueDataParamsNV& copy_src);
safe_VkExternalComputeQueueDataParamsNV& operator=(const safe_VkExternalComputeQueueDataParamsNV& copy_src);
safe_VkExternalComputeQueueDataParamsNV();
~safe_VkExternalComputeQueueDataParamsNV();
void initialize(const VkExternalComputeQueueDataParamsNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkExternalComputeQueueDataParamsNV* copy_src, PNextCopyState* copy_state = {});
VkExternalComputeQueueDataParamsNV* ptr() { return reinterpret_cast<VkExternalComputeQueueDataParamsNV*>(this); }
VkExternalComputeQueueDataParamsNV const* ptr() const {
return reinterpret_cast<VkExternalComputeQueueDataParamsNV const*>(this);
}
};
struct safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV {
VkStructureType sType;
void* pNext{};
uint32_t externalDataSize;
uint32_t maxExternalQueues;
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct,
PNextCopyState* copy_state = {}, bool copy_pnext = true);
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src);
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& operator=(
const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src);
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV();
~safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV();
void initialize(const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, PNextCopyState* copy_state = {});
void initialize(const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV* copy_src, PNextCopyState* copy_state = {});
VkPhysicalDeviceExternalComputeQueuePropertiesNV* ptr() {
return reinterpret_cast<VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(this);
}
VkPhysicalDeviceExternalComputeQueuePropertiesNV const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceExternalComputeQueuePropertiesNV const*>(this);
}
};
struct safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
VkStructureType sType;
void* pNext{};

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

@ -751,6 +751,12 @@ template <> inline VkStructureType GetSType<VkCudaLaunchInfoNV>() { return VK_ST
template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; }
#endif // VK_ENABLE_BETA_EXTENSIONS
template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; }
template <> inline VkStructureType GetSType<VkRenderPassTileShadingCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; }
template <> inline VkStructureType GetSType<VkPerTileBeginInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; }
template <> inline VkStructureType GetSType<VkPerTileEndInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; }
template <> inline VkStructureType GetSType<VkDispatchTileInfoQCOM>() { return VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; }
template <> inline VkStructureType GetSType<VkQueryLowLatencySupportNV>() { return VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; }
#ifdef VK_USE_PLATFORM_METAL_EXT
template <> inline VkStructureType GetSType<VkExportMetalObjectCreateInfoEXT>() { return VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; }
@ -1004,6 +1010,10 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOveral
template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkExternalComputeQueueDeviceCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; }
template <> inline VkStructureType GetSType<VkExternalComputeQueueCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; }
template <> inline VkStructureType GetSType<VkExternalComputeQueueDataParamsNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalComputeQueuePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
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; }
@ -1209,6 +1219,7 @@ template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { retu
template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
template<> inline VkObjectType GetObjectType<VkExternalComputeQueueNV>() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; }
template<> inline VkObjectType GetObjectType<VkIndirectExecutionSetEXT>() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; }
template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutEXT>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; }

53
include/vulkan/vk_enum_string_helper.h
View file

@ -1422,6 +1422,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV";
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM";
case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
return "VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM";
case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
return "VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM";
case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
return "VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM";
case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
return "VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM";
case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
return "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV";
case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
@ -2006,6 +2018,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV";
case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV";
case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
@ -2326,6 +2346,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
return "VK_OBJECT_TYPE_SHADER_EXT";
case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR:
return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR";
case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV:
return "VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV";
case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT:
return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT";
case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT:
@ -6794,6 +6816,8 @@ static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescripti
return "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM";
case VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM:
return "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM";
case VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM:
return "VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM";
case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT:
return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT";
case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT:
@ -7591,6 +7615,8 @@ static inline const char* string_VkAccessFlagBits2(uint64_t input_value) {
if (input_value == VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR) return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
if (input_value == VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR) return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
if (input_value == VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR) return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
if (input_value == VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM) return "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM";
if (input_value == VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM) return "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM";
if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
@ -9530,6 +9556,33 @@ static inline std::string string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagno
return ret;
}
#endif // __cplusplus
static inline const char* string_VkTileShadingRenderPassFlagBitsQCOM(VkTileShadingRenderPassFlagBitsQCOM input_value) {
switch (input_value) {
case VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM:
return "VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM";
case VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM:
return "VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM";
default:
return "Unhandled VkTileShadingRenderPassFlagBitsQCOM";
}
}
#ifdef __cplusplus
static inline std::string string_VkTileShadingRenderPassFlagsQCOM(VkTileShadingRenderPassFlagsQCOM input_value) {
std::string ret;
int index = 0;
while(input_value) {
if (input_value & 1) {
if( !ret.empty()) ret.append("|");
ret.append(string_VkTileShadingRenderPassFlagBitsQCOM(static_cast<VkTileShadingRenderPassFlagBitsQCOM>(1U << index)));
}
++index;
input_value >>= 1;
}
if (ret.empty()) ret.append("VkTileShadingRenderPassFlagsQCOM(0)");
return ret;
}
#endif // __cplusplus
#ifdef VK_USE_PLATFORM_METAL_EXT
static inline const char* string_VkExportMetalObjectTypeFlagBitsEXT(VkExportMetalObjectTypeFlagBitsEXT input_value) {
switch (input_value) {

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.311"
"commit": "v1.4.312"
},
{
"name": "googletest",

30
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -1391,6 +1391,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(pNext), copy_state, false);
break;
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
safe_pNext = new safe_VkPhysicalDeviceTileShadingFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
safe_pNext = new safe_VkPhysicalDeviceTileShadingPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
safe_pNext = new safe_VkRenderPassTileShadingCreateInfoQCOM(reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast<const VkQueryLowLatencySupportNV *>(pNext), copy_state, false);
break;
@ -1947,6 +1956,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
safe_pNext = new safe_VkExternalComputeQueueDeviceCreateInfoNV(reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
safe_pNext = new safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(pNext), copy_state, false);
break;
@ -3445,6 +3460,15 @@ void FreePnextChain(const void *pNext) {
delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
break;
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
delete reinterpret_cast<safe_VkPhysicalDeviceTileShadingFeaturesQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
delete reinterpret_cast<safe_VkPhysicalDeviceTileShadingPropertiesQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
delete reinterpret_cast<safe_VkRenderPassTileShadingCreateInfoQCOM *>(header);
break;
case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
delete reinterpret_cast<safe_VkQueryLowLatencySupportNV *>(header);
break;
@ -4001,6 +4025,12 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
delete reinterpret_cast<safe_VkExternalComputeQueueDeviceCreateInfoNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(header);
break;

570
src/vulkan/vk_safe_struct_vendor.cpp
View file

@ -8275,6 +8275,375 @@ void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(
}
#endif // VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM(
const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
tileShading(in_struct->tileShading),
tileShadingFragmentStage(in_struct->tileShadingFragmentStage),
tileShadingColorAttachments(in_struct->tileShadingColorAttachments),
tileShadingDepthAttachments(in_struct->tileShadingDepthAttachments),
tileShadingStencilAttachments(in_struct->tileShadingStencilAttachments),
tileShadingInputAttachments(in_struct->tileShadingInputAttachments),
tileShadingSampledAttachments(in_struct->tileShadingSampledAttachments),
tileShadingPerTileDraw(in_struct->tileShadingPerTileDraw),
tileShadingPerTileDispatch(in_struct->tileShadingPerTileDispatch),
tileShadingDispatchTile(in_struct->tileShadingDispatchTile),
tileShadingApron(in_struct->tileShadingApron),
tileShadingAnisotropicApron(in_struct->tileShadingAnisotropicApron),
tileShadingAtomicOps(in_struct->tileShadingAtomicOps),
tileShadingImageProcessing(in_struct->tileShadingImageProcessing) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM),
pNext(nullptr),
tileShading(),
tileShadingFragmentStage(),
tileShadingColorAttachments(),
tileShadingDepthAttachments(),
tileShadingStencilAttachments(),
tileShadingInputAttachments(),
tileShadingSampledAttachments(),
tileShadingPerTileDraw(),
tileShadingPerTileDispatch(),
tileShadingDispatchTile(),
tileShadingApron(),
tileShadingAnisotropicApron(),
tileShadingAtomicOps(),
tileShadingImageProcessing() {}
safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM(
const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src) {
sType = copy_src.sType;
tileShading = copy_src.tileShading;
tileShadingFragmentStage = copy_src.tileShadingFragmentStage;
tileShadingColorAttachments = copy_src.tileShadingColorAttachments;
tileShadingDepthAttachments = copy_src.tileShadingDepthAttachments;
tileShadingStencilAttachments = copy_src.tileShadingStencilAttachments;
tileShadingInputAttachments = copy_src.tileShadingInputAttachments;
tileShadingSampledAttachments = copy_src.tileShadingSampledAttachments;
tileShadingPerTileDraw = copy_src.tileShadingPerTileDraw;
tileShadingPerTileDispatch = copy_src.tileShadingPerTileDispatch;
tileShadingDispatchTile = copy_src.tileShadingDispatchTile;
tileShadingApron = copy_src.tileShadingApron;
tileShadingAnisotropicApron = copy_src.tileShadingAnisotropicApron;
tileShadingAtomicOps = copy_src.tileShadingAtomicOps;
tileShadingImageProcessing = copy_src.tileShadingImageProcessing;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTileShadingFeaturesQCOM& safe_VkPhysicalDeviceTileShadingFeaturesQCOM::operator=(
const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
tileShading = copy_src.tileShading;
tileShadingFragmentStage = copy_src.tileShadingFragmentStage;
tileShadingColorAttachments = copy_src.tileShadingColorAttachments;
tileShadingDepthAttachments = copy_src.tileShadingDepthAttachments;
tileShadingStencilAttachments = copy_src.tileShadingStencilAttachments;
tileShadingInputAttachments = copy_src.tileShadingInputAttachments;
tileShadingSampledAttachments = copy_src.tileShadingSampledAttachments;
tileShadingPerTileDraw = copy_src.tileShadingPerTileDraw;
tileShadingPerTileDispatch = copy_src.tileShadingPerTileDispatch;
tileShadingDispatchTile = copy_src.tileShadingDispatchTile;
tileShadingApron = copy_src.tileShadingApron;
tileShadingAnisotropicApron = copy_src.tileShadingAnisotropicApron;
tileShadingAtomicOps = copy_src.tileShadingAtomicOps;
tileShadingImageProcessing = copy_src.tileShadingImageProcessing;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTileShadingFeaturesQCOM::~safe_VkPhysicalDeviceTileShadingFeaturesQCOM() { FreePnextChain(pNext); }
void safe_VkPhysicalDeviceTileShadingFeaturesQCOM::initialize(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
tileShading = in_struct->tileShading;
tileShadingFragmentStage = in_struct->tileShadingFragmentStage;
tileShadingColorAttachments = in_struct->tileShadingColorAttachments;
tileShadingDepthAttachments = in_struct->tileShadingDepthAttachments;
tileShadingStencilAttachments = in_struct->tileShadingStencilAttachments;
tileShadingInputAttachments = in_struct->tileShadingInputAttachments;
tileShadingSampledAttachments = in_struct->tileShadingSampledAttachments;
tileShadingPerTileDraw = in_struct->tileShadingPerTileDraw;
tileShadingPerTileDispatch = in_struct->tileShadingPerTileDispatch;
tileShadingDispatchTile = in_struct->tileShadingDispatchTile;
tileShadingApron = in_struct->tileShadingApron;
tileShadingAnisotropicApron = in_struct->tileShadingAnisotropicApron;
tileShadingAtomicOps = in_struct->tileShadingAtomicOps;
tileShadingImageProcessing = in_struct->tileShadingImageProcessing;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceTileShadingFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
tileShading = copy_src->tileShading;
tileShadingFragmentStage = copy_src->tileShadingFragmentStage;
tileShadingColorAttachments = copy_src->tileShadingColorAttachments;
tileShadingDepthAttachments = copy_src->tileShadingDepthAttachments;
tileShadingStencilAttachments = copy_src->tileShadingStencilAttachments;
tileShadingInputAttachments = copy_src->tileShadingInputAttachments;
tileShadingSampledAttachments = copy_src->tileShadingSampledAttachments;
tileShadingPerTileDraw = copy_src->tileShadingPerTileDraw;
tileShadingPerTileDispatch = copy_src->tileShadingPerTileDispatch;
tileShadingDispatchTile = copy_src->tileShadingDispatchTile;
tileShadingApron = copy_src->tileShadingApron;
tileShadingAnisotropicApron = copy_src->tileShadingAnisotropicApron;
tileShadingAtomicOps = copy_src->tileShadingAtomicOps;
tileShadingImageProcessing = copy_src->tileShadingImageProcessing;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM(
const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType),
maxApronSize(in_struct->maxApronSize),
preferNonCoherent(in_struct->preferNonCoherent),
tileGranularity(in_struct->tileGranularity),
maxTileShadingRate(in_struct->maxTileShadingRate) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM),
pNext(nullptr),
maxApronSize(),
preferNonCoherent(),
tileGranularity(),
maxTileShadingRate() {}
safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM(
const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src) {
sType = copy_src.sType;
maxApronSize = copy_src.maxApronSize;
preferNonCoherent = copy_src.preferNonCoherent;
tileGranularity = copy_src.tileGranularity;
maxTileShadingRate = copy_src.maxTileShadingRate;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceTileShadingPropertiesQCOM& safe_VkPhysicalDeviceTileShadingPropertiesQCOM::operator=(
const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
maxApronSize = copy_src.maxApronSize;
preferNonCoherent = copy_src.preferNonCoherent;
tileGranularity = copy_src.tileGranularity;
maxTileShadingRate = copy_src.maxTileShadingRate;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceTileShadingPropertiesQCOM::~safe_VkPhysicalDeviceTileShadingPropertiesQCOM() { FreePnextChain(pNext); }
void safe_VkPhysicalDeviceTileShadingPropertiesQCOM::initialize(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
maxApronSize = in_struct->maxApronSize;
preferNonCoherent = in_struct->preferNonCoherent;
tileGranularity = in_struct->tileGranularity;
maxTileShadingRate = in_struct->maxTileShadingRate;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceTileShadingPropertiesQCOM::initialize(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
maxApronSize = copy_src->maxApronSize;
preferNonCoherent = copy_src->preferNonCoherent;
tileGranularity = copy_src->tileGranularity;
maxTileShadingRate = copy_src->maxTileShadingRate;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM(
const VkRenderPassTileShadingCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), flags(in_struct->flags), tileApronSize(in_struct->tileApronSize) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM()
: sType(VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM), pNext(nullptr), flags(), tileApronSize() {}
safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM(
const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src) {
sType = copy_src.sType;
flags = copy_src.flags;
tileApronSize = copy_src.tileApronSize;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkRenderPassTileShadingCreateInfoQCOM& safe_VkRenderPassTileShadingCreateInfoQCOM::operator=(
const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
flags = copy_src.flags;
tileApronSize = copy_src.tileApronSize;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkRenderPassTileShadingCreateInfoQCOM::~safe_VkRenderPassTileShadingCreateInfoQCOM() { FreePnextChain(pNext); }
void safe_VkRenderPassTileShadingCreateInfoQCOM::initialize(const VkRenderPassTileShadingCreateInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
flags = in_struct->flags;
tileApronSize = in_struct->tileApronSize;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkRenderPassTileShadingCreateInfoQCOM::initialize(const safe_VkRenderPassTileShadingCreateInfoQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
flags = copy_src->flags;
tileApronSize = copy_src->tileApronSize;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM() : sType(VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM), pNext(nullptr) {}
safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM(const safe_VkPerTileBeginInfoQCOM& copy_src) {
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerTileBeginInfoQCOM& safe_VkPerTileBeginInfoQCOM::operator=(const safe_VkPerTileBeginInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerTileBeginInfoQCOM::~safe_VkPerTileBeginInfoQCOM() { FreePnextChain(pNext); }
void safe_VkPerTileBeginInfoQCOM::initialize(const VkPerTileBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPerTileBeginInfoQCOM::initialize(const safe_VkPerTileBeginInfoQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM() : sType(VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM), pNext(nullptr) {}
safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM(const safe_VkPerTileEndInfoQCOM& copy_src) {
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPerTileEndInfoQCOM& safe_VkPerTileEndInfoQCOM::operator=(const safe_VkPerTileEndInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPerTileEndInfoQCOM::~safe_VkPerTileEndInfoQCOM() { FreePnextChain(pNext); }
void safe_VkPerTileEndInfoQCOM::initialize(const VkPerTileEndInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPerTileEndInfoQCOM::initialize(const safe_VkPerTileEndInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM() : sType(VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM), pNext(nullptr) {}
safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM(const safe_VkDispatchTileInfoQCOM& copy_src) {
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkDispatchTileInfoQCOM& safe_VkDispatchTileInfoQCOM::operator=(const safe_VkDispatchTileInfoQCOM& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkDispatchTileInfoQCOM::~safe_VkDispatchTileInfoQCOM() { FreePnextChain(pNext); }
void safe_VkDispatchTileInfoQCOM::initialize(const VkDispatchTileInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkDispatchTileInfoQCOM::initialize(const safe_VkDispatchTileInfoQCOM* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), pQueriedLowLatencyData(in_struct->pQueriedLowLatencyData) {
@ -15723,6 +16092,207 @@ void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const safe_VkPhy
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV(
const VkExternalComputeQueueDeviceCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), reservedExternalQueues(in_struct->reservedExternalQueues) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV()
: sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV), pNext(nullptr), reservedExternalQueues() {}
safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV(
const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src) {
sType = copy_src.sType;
reservedExternalQueues = copy_src.reservedExternalQueues;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalComputeQueueDeviceCreateInfoNV& safe_VkExternalComputeQueueDeviceCreateInfoNV::operator=(
const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
reservedExternalQueues = copy_src.reservedExternalQueues;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalComputeQueueDeviceCreateInfoNV::~safe_VkExternalComputeQueueDeviceCreateInfoNV() { FreePnextChain(pNext); }
void safe_VkExternalComputeQueueDeviceCreateInfoNV::initialize(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
reservedExternalQueues = in_struct->reservedExternalQueues;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkExternalComputeQueueDeviceCreateInfoNV::initialize(const safe_VkExternalComputeQueueDeviceCreateInfoNV* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
reservedExternalQueues = copy_src->reservedExternalQueues;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV(
const VkExternalComputeQueueCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), preferredQueue(in_struct->preferredQueue) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV()
: sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV), pNext(nullptr), preferredQueue() {}
safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV(
const safe_VkExternalComputeQueueCreateInfoNV& copy_src) {
sType = copy_src.sType;
preferredQueue = copy_src.preferredQueue;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalComputeQueueCreateInfoNV& safe_VkExternalComputeQueueCreateInfoNV::operator=(
const safe_VkExternalComputeQueueCreateInfoNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
preferredQueue = copy_src.preferredQueue;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalComputeQueueCreateInfoNV::~safe_VkExternalComputeQueueCreateInfoNV() { FreePnextChain(pNext); }
void safe_VkExternalComputeQueueCreateInfoNV::initialize(const VkExternalComputeQueueCreateInfoNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
preferredQueue = in_struct->preferredQueue;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkExternalComputeQueueCreateInfoNV::initialize(const safe_VkExternalComputeQueueCreateInfoNV* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
preferredQueue = copy_src->preferredQueue;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV(
const VkExternalComputeQueueDataParamsNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), deviceIndex(in_struct->deviceIndex) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV()
: sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV), pNext(nullptr), deviceIndex() {}
safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV(
const safe_VkExternalComputeQueueDataParamsNV& copy_src) {
sType = copy_src.sType;
deviceIndex = copy_src.deviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkExternalComputeQueueDataParamsNV& safe_VkExternalComputeQueueDataParamsNV::operator=(
const safe_VkExternalComputeQueueDataParamsNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
deviceIndex = copy_src.deviceIndex;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkExternalComputeQueueDataParamsNV::~safe_VkExternalComputeQueueDataParamsNV() { FreePnextChain(pNext); }
void safe_VkExternalComputeQueueDataParamsNV::initialize(const VkExternalComputeQueueDataParamsNV* in_struct,
[[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
deviceIndex = in_struct->deviceIndex;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkExternalComputeQueueDataParamsNV::initialize(const safe_VkExternalComputeQueueDataParamsNV* copy_src,
[[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
deviceIndex = copy_src->deviceIndex;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(
const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
: sType(in_struct->sType), externalDataSize(in_struct->externalDataSize), maxExternalQueues(in_struct->maxExternalQueues) {
if (copy_pnext) {
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
}
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV()
: sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV),
pNext(nullptr),
externalDataSize(),
maxExternalQueues() {}
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(
const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src) {
sType = copy_src.sType;
externalDataSize = copy_src.externalDataSize;
maxExternalQueues = copy_src.maxExternalQueues;
pNext = SafePnextCopy(copy_src.pNext);
}
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::operator=(
const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src) {
if (&copy_src == this) return *this;
FreePnextChain(pNext);
sType = copy_src.sType;
externalDataSize = copy_src.externalDataSize;
maxExternalQueues = copy_src.maxExternalQueues;
pNext = SafePnextCopy(copy_src.pNext);
return *this;
}
safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::~safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV() {
FreePnextChain(pNext);
}
void safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::initialize(
const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
FreePnextChain(pNext);
sType = in_struct->sType;
externalDataSize = in_struct->externalDataSize;
maxExternalQueues = in_struct->maxExternalQueues;
pNext = SafePnextCopy(in_struct->pNext, copy_state);
}
void safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::initialize(
const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
sType = copy_src->sType;
externalDataSize = copy_src->externalDataSize;
maxExternalQueues = copy_src->maxExternalQueues;
pNext = SafePnextCopy(copy_src->pNext);
}
safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(
const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
bool copy_pnext)