diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index d68b79a..f13b592 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -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"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 42bdb85..74449f7 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -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(this); } + VkPhysicalDeviceTileShadingFeaturesQCOM const* ptr() const { + return reinterpret_cast(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(this); } + VkPhysicalDeviceTileShadingPropertiesQCOM const* ptr() const { + return reinterpret_cast(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(this); } + VkRenderPassTileShadingCreateInfoQCOM const* ptr() const { + return reinterpret_cast(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(this); } + VkPerTileBeginInfoQCOM const* ptr() const { return reinterpret_cast(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(this); } + VkPerTileEndInfoQCOM const* ptr() const { return reinterpret_cast(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(this); } + VkDispatchTileInfoQCOM const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkQueryLowLatencySupportNV { VkStructureType sType; const void* pNext{}; @@ -19233,6 +19346,82 @@ struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV { return reinterpret_cast(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(this); } + VkExternalComputeQueueDeviceCreateInfoNV const* ptr() const { + return reinterpret_cast(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(this); } + VkExternalComputeQueueCreateInfoNV const* ptr() const { + return reinterpret_cast(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(this); } + VkExternalComputeQueueDataParamsNV const* ptr() const { + return reinterpret_cast(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(this); + } + VkPhysicalDeviceExternalComputeQueuePropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV { VkStructureType sType; void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index b9dc50e..ee1ce72 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -751,6 +751,12 @@ template <> inline VkStructureType GetSType() { return VK_ST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; } #endif // VK_ENABLE_BETA_EXTENSIONS +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; } #ifdef VK_USE_PLATFORM_METAL_EXT template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; } @@ -1004,6 +1010,10 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; } @@ -1209,6 +1219,7 @@ template<> inline VkObjectType GetObjectType() { retu template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_MICROMAP_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_SHADER_EXT; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index 3c30dd4..e821927 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -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(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) { diff --git a/scripts/known_good.json b/scripts/known_good.json index 9f83ed8..c829994 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -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", diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index cdcfb69..d6357da 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -1391,6 +1391,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast(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(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceTileShadingPropertiesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + safe_pNext = new safe_VkRenderPassTileShadingCreateInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast(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(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: + safe_pNext = new safe_VkExternalComputeQueueDeviceCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; @@ -3445,6 +3460,15 @@ void FreePnextChain(const void *pNext) { delete reinterpret_cast(header); break; #endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: delete reinterpret_cast(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(header); break; + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: delete reinterpret_cast(header); break; diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp index e12547c..163c488 100644 --- a/src/vulkan/vk_safe_struct_vendor.cpp +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -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 (©_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 (©_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 (©_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 (©_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 (©_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 (©_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 (©_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 (©_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 (©_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 (©_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)