From 4c1b9fd52cafa21d11b7920e9bc6f500e0e195e2 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Thu, 9 Apr 2026 19:16:59 -0700 Subject: [PATCH 1/2] ci: Turn off chromium build The chromium.googlesource.com servers have started to give us 503 error codes. Disabling while we investigate --- .github/workflows/ci.yml | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0175739..2d1577f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,8 +14,7 @@ on: jobs: build_and_test: - # Use chromium as a test build, so don't run this job unless something simple works first - needs: chromium + needs: generate_source runs-on: ${{matrix.os}} strategy: matrix: @@ -34,8 +33,7 @@ jobs: working-directory: build/ windows-arm64: - # Use chromium as a test build, so don't run this job unless something simple works first - needs: chromium + needs: generate_source runs-on: windows-latest env: CMAKE_GENERATOR: Ninja @@ -49,8 +47,7 @@ jobs: - run: cmake --install build --prefix build/install android: - # Use chromium as a test build, so don't run this job unless something simple works first - needs: chromium + needs: generate_source runs-on: ubuntu-24.04 strategy: matrix: @@ -84,18 +81,18 @@ jobs: uses: fsfe/reuse-action@v6 # Test to ensure we don't accidentally break the Chromium build. - chromium: - needs: generate_source - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6 - - uses: actions/setup-python@v6 - with: - python-version: '3.10' - - name: Install WSI dependencies - run: sudo apt-get -qq update && sudo apt-get install -y libwayland-dev xorg-dev - - name: Test chromium build - run: python scripts/gn/gn.py + # chromium: + # needs: generate_source + # runs-on: ubuntu-24.04 + # steps: + # - uses: actions/checkout@v6 + # - uses: actions/setup-python@v6 + # with: + # python-version: '3.10' + # - name: Install WSI dependencies + # run: sudo apt-get -qq update && sudo apt-get install -y libwayland-dev xorg-dev + # - name: Test chromium build + # run: python scripts/gn/gn.py generate_source: runs-on: ubuntu-24.04 From 6ca0894145a17a1aa0d87e1d41ad72c1f1e7daec Mon Sep 17 00:00:00 2001 From: "headerbot[bot]" <(none)> Date: Thu, 9 Apr 2026 18:15:58 -0700 Subject: [PATCH 2/2] build: Update to header v1.4.349 --- CMakeLists.txt | 2 +- include/vulkan/utility/vk_dispatch_table.h | 2 + include/vulkan/utility/vk_safe_struct.hpp | 203 +++++++ include/vulkan/utility/vk_struct_helper.hpp | 9 + include/vulkan/vk_enum_string_helper.h | 210 +++++++ scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_utils.cpp | 36 ++ src/vulkan/vk_safe_struct_vendor.cpp | 593 ++++++++++++++++++++ 8 files changed, 1055 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 45a9397..2e92492 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.22.1) # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script -project(VUL VERSION 1.4.347 LANGUAGES CXX) +project(VUL VERSION 1.4.349 LANGUAGES CXX) set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143 diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index 1397b92..f87414d 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -173,6 +173,7 @@ typedef struct VkuInstanceDispatchTable_ { PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV; PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM; PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM EnumeratePhysicalDeviceShaderInstrumentationMetricsARM; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM; #ifdef VK_USE_PLATFORM_UBM_SEC PFN_vkCreateUbmSurfaceSEC CreateUbmSurfaceSEC; PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC GetPhysicalDeviceUbmPresentationSupportSEC; @@ -1792,6 +1793,7 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); table->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = (PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)gipa(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"); table->EnumeratePhysicalDeviceShaderInstrumentationMetricsARM = (PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM)gipa(instance, "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM"); + table->GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = (PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM)gipa(instance, "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM"); #ifdef VK_USE_PLATFORM_UBM_SEC table->CreateUbmSurfaceSEC = (PFN_vkCreateUbmSurfaceSEC)gipa(instance, "vkCreateUbmSurfaceSEC"); table->GetPhysicalDeviceUbmPresentationSupportSEC = (PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC)gipa(instance, "vkGetPhysicalDeviceUbmPresentationSupportSEC"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 1f41ff0..42b4b1e 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -24200,6 +24200,209 @@ struct safe_VkPhysicalDeviceDataGraphModelFeaturesQCOM { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 dataGraphOpticalFlow; + + safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& copy_src); + safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& operator=( + const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& copy_src); + safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(); + ~safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(); + void initialize(const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM { + VkStructureType sType; + void* pNext{}; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedOutputGridSizes; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + + safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM(const VkQueueFamilyDataGraphOpticalFlowPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM(const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& copy_src); + safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& operator=( + const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& copy_src); + safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM(); + ~safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM(); + void initialize(const VkQueueFamilyDataGraphOpticalFlowPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyDataGraphOpticalFlowPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkQueueFamilyDataGraphOpticalFlowPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphPipelineOpticalFlowCreateInfoARM { + VkStructureType sType; + void* pNext{}; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkDataGraphOpticalFlowGridSizeFlagsARM outputGridSize; + VkDataGraphOpticalFlowGridSizeFlagsARM hintGridSize; + VkDataGraphOpticalFlowPerformanceLevelARM performanceLevel; + VkDataGraphOpticalFlowCreateFlagsARM flags; + + safe_VkDataGraphPipelineOpticalFlowCreateInfoARM(const VkDataGraphPipelineOpticalFlowCreateInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphPipelineOpticalFlowCreateInfoARM(const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& copy_src); + safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& operator=(const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& copy_src); + safe_VkDataGraphPipelineOpticalFlowCreateInfoARM(); + ~safe_VkDataGraphPipelineOpticalFlowCreateInfoARM(); + void initialize(const VkDataGraphPipelineOpticalFlowCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphPipelineOpticalFlowCreateInfoARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphPipelineOpticalFlowCreateInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphOpticalFlowImageFormatPropertiesARM { + VkStructureType sType; + void* pNext{}; + VkFormat format; + + safe_VkDataGraphOpticalFlowImageFormatPropertiesARM(const VkDataGraphOpticalFlowImageFormatPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphOpticalFlowImageFormatPropertiesARM(const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& copy_src); + safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& operator=( + const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& copy_src); + safe_VkDataGraphOpticalFlowImageFormatPropertiesARM(); + ~safe_VkDataGraphOpticalFlowImageFormatPropertiesARM(); + void initialize(const VkDataGraphOpticalFlowImageFormatPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphOpticalFlowImageFormatPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphOpticalFlowImageFormatPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphOpticalFlowImageFormatInfoARM { + VkStructureType sType; + const void* pNext{}; + VkDataGraphOpticalFlowImageUsageFlagsARM usage; + + safe_VkDataGraphOpticalFlowImageFormatInfoARM(const VkDataGraphOpticalFlowImageFormatInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphOpticalFlowImageFormatInfoARM(const safe_VkDataGraphOpticalFlowImageFormatInfoARM& copy_src); + safe_VkDataGraphOpticalFlowImageFormatInfoARM& operator=(const safe_VkDataGraphOpticalFlowImageFormatInfoARM& copy_src); + safe_VkDataGraphOpticalFlowImageFormatInfoARM(); + ~safe_VkDataGraphOpticalFlowImageFormatInfoARM(); + void initialize(const VkDataGraphOpticalFlowImageFormatInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphOpticalFlowImageFormatInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphOpticalFlowImageFormatInfoARM* ptr() { return reinterpret_cast(this); } + VkDataGraphOpticalFlowImageFormatInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM { + VkStructureType sType; + void* pNext{}; + VkDataGraphOpticalFlowExecuteFlagsARM flags; + uint32_t meanFlowL1NormHint; + + safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM(const VkDataGraphPipelineOpticalFlowDispatchInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM(const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& copy_src); + safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& operator=( + const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& copy_src); + safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM(); + ~safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM(); + void initialize(const VkDataGraphPipelineOpticalFlowDispatchInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphPipelineOpticalFlowDispatchInfoARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphPipelineOpticalFlowDispatchInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphPipelineResourceInfoImageLayoutARM { + VkStructureType sType; + const void* pNext{}; + VkImageLayout layout; + + safe_VkDataGraphPipelineResourceInfoImageLayoutARM(const VkDataGraphPipelineResourceInfoImageLayoutARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphPipelineResourceInfoImageLayoutARM(const safe_VkDataGraphPipelineResourceInfoImageLayoutARM& copy_src); + safe_VkDataGraphPipelineResourceInfoImageLayoutARM& operator=( + const safe_VkDataGraphPipelineResourceInfoImageLayoutARM& copy_src); + safe_VkDataGraphPipelineResourceInfoImageLayoutARM(); + ~safe_VkDataGraphPipelineResourceInfoImageLayoutARM(); + void initialize(const VkDataGraphPipelineResourceInfoImageLayoutARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphPipelineResourceInfoImageLayoutARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphPipelineResourceInfoImageLayoutARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphPipelineResourceInfoImageLayoutARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphPipelineSingleNodeConnectionARM { + VkStructureType sType; + void* pNext{}; + uint32_t set; + uint32_t binding; + VkDataGraphPipelineNodeConnectionTypeARM connection; + + safe_VkDataGraphPipelineSingleNodeConnectionARM(const VkDataGraphPipelineSingleNodeConnectionARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphPipelineSingleNodeConnectionARM(const safe_VkDataGraphPipelineSingleNodeConnectionARM& copy_src); + safe_VkDataGraphPipelineSingleNodeConnectionARM& operator=(const safe_VkDataGraphPipelineSingleNodeConnectionARM& copy_src); + safe_VkDataGraphPipelineSingleNodeConnectionARM(); + ~safe_VkDataGraphPipelineSingleNodeConnectionARM(); + void initialize(const VkDataGraphPipelineSingleNodeConnectionARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphPipelineSingleNodeConnectionARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphPipelineSingleNodeConnectionARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphPipelineSingleNodeConnectionARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDataGraphPipelineSingleNodeCreateInfoARM { + VkStructureType sType; + void* pNext{}; + VkDataGraphPipelineNodeTypeARM nodeType; + uint32_t connectionCount; + safe_VkDataGraphPipelineSingleNodeConnectionARM* pConnections{}; + + safe_VkDataGraphPipelineSingleNodeCreateInfoARM(const VkDataGraphPipelineSingleNodeCreateInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDataGraphPipelineSingleNodeCreateInfoARM(const safe_VkDataGraphPipelineSingleNodeCreateInfoARM& copy_src); + safe_VkDataGraphPipelineSingleNodeCreateInfoARM& operator=(const safe_VkDataGraphPipelineSingleNodeCreateInfoARM& copy_src); + safe_VkDataGraphPipelineSingleNodeCreateInfoARM(); + ~safe_VkDataGraphPipelineSingleNodeCreateInfoARM(); + void initialize(const VkDataGraphPipelineSingleNodeCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDataGraphPipelineSingleNodeCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDataGraphPipelineSingleNodeCreateInfoARM* ptr() { + return reinterpret_cast(this); + } + VkDataGraphPipelineSingleNodeCreateInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceShaderLongVectorFeaturesEXT { VkStructureType sType; void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index cffd12c..92b5859 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -1249,6 +1249,15 @@ template <> inline VkStructureType GetSType() { ret template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index 71cedfb..04eac2a 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -2514,6 +2514,24 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR"; case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: return "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM"; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM: + return "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: @@ -5692,6 +5710,8 @@ static inline const char* string_VkDataGraphPipelineSessionBindPointARM(VkDataGr switch (input_value) { case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: return "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM"; + case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM: + return "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM"; default: return "Unhandled VkDataGraphPipelineSessionBindPointARM"; } @@ -5734,6 +5754,8 @@ static inline const char* string_VkPhysicalDeviceDataGraphOperationTypeARM(VkPhy return "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM"; case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: return "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM"; + case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM: + return "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM"; default: return "Unhandled VkPhysicalDeviceDataGraphOperationTypeARM"; } @@ -5908,6 +5930,44 @@ static inline const char* string_VkDataGraphModelCacheTypeQCOM(VkDataGraphModelC return "Unhandled VkDataGraphModelCacheTypeQCOM"; } } +static inline const char* string_VkDataGraphOpticalFlowPerformanceLevelARM(VkDataGraphOpticalFlowPerformanceLevelARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM"; + default: + return "Unhandled VkDataGraphOpticalFlowPerformanceLevelARM"; + } +} +static inline const char* string_VkDataGraphPipelineNodeTypeARM(VkDataGraphPipelineNodeTypeARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM"; + default: + return "Unhandled VkDataGraphPipelineNodeTypeARM"; + } +} +static inline const char* string_VkDataGraphPipelineNodeConnectionTypeARM(VkDataGraphPipelineNodeConnectionTypeARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM"; + case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM"; + case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM"; + case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM"; + case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM: + return "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM"; + default: + return "Unhandled VkDataGraphPipelineNodeConnectionTypeARM"; + } +} static inline const char* string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value) { switch (input_value) { case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: @@ -8413,6 +8473,9 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) if (input_value == VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR) return "VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR) return "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR) return "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR"; + if (input_value == VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM) return "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM"; + if (input_value == VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM) return "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM"; + if (input_value == VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM) return "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM"; return "Unhandled VkFormatFeatureFlagBits2"; } @@ -11368,6 +11431,7 @@ static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT i #endif // __cplusplus static inline const char* string_VkDataGraphPipelineSessionCreateFlagBitsARM(uint64_t input_value) { if (input_value == VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM) return "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM"; + if (input_value == VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM) return "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM"; return "Unhandled VkDataGraphPipelineSessionCreateFlagBitsARM"; } @@ -11625,6 +11689,134 @@ static inline std::string string_VkIndirectCommandsLayoutUsageFlagsEXT(VkIndirec return ret; } #endif // __cplusplus +static inline const char* string_VkDataGraphOpticalFlowGridSizeFlagBitsARM(VkDataGraphOpticalFlowGridSizeFlagBitsARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM"; + default: + return "Unhandled VkDataGraphOpticalFlowGridSizeFlagBitsARM"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkDataGraphOpticalFlowGridSizeFlagsARM(VkDataGraphOpticalFlowGridSizeFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkDataGraphOpticalFlowGridSizeFlagBitsARM(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkDataGraphOpticalFlowGridSizeFlagsARM(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkDataGraphOpticalFlowCreateFlagBitsARM(VkDataGraphOpticalFlowCreateFlagBitsARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM"; + default: + return "Unhandled VkDataGraphOpticalFlowCreateFlagBitsARM"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkDataGraphOpticalFlowCreateFlagsARM(VkDataGraphOpticalFlowCreateFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkDataGraphOpticalFlowCreateFlagBitsARM(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkDataGraphOpticalFlowCreateFlagsARM(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkDataGraphOpticalFlowImageUsageFlagBitsARM(VkDataGraphOpticalFlowImageUsageFlagBitsARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM"; + default: + return "Unhandled VkDataGraphOpticalFlowImageUsageFlagBitsARM"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkDataGraphOpticalFlowImageUsageFlagsARM(VkDataGraphOpticalFlowImageUsageFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkDataGraphOpticalFlowImageUsageFlagBitsARM(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkDataGraphOpticalFlowImageUsageFlagsARM(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkDataGraphOpticalFlowExecuteFlagBitsARM(VkDataGraphOpticalFlowExecuteFlagBitsARM input_value) { + switch (input_value) { + case VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM"; + case VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM: + return "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM"; + default: + return "Unhandled VkDataGraphOpticalFlowExecuteFlagBitsARM"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkDataGraphOpticalFlowExecuteFlagsARM(VkDataGraphOpticalFlowExecuteFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkDataGraphOpticalFlowExecuteFlagBitsARM(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkDataGraphOpticalFlowExecuteFlagsARM(0)"); + return ret; +} +#endif // __cplusplus // clang-format on // Same thing as string_VkStructureType, but prints out the API name @@ -14028,6 +14220,24 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkDataGraphPipelineBuiltinModelCreateInfoQCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: return "VkPhysicalDeviceDataGraphModelFeaturesQCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: + return "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM"; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM: + return "VkQueueFamilyDataGraphOpticalFlowPropertiesARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM: + return "VkDataGraphPipelineOpticalFlowCreateInfoARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM: + return "VkDataGraphOpticalFlowImageFormatPropertiesARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM: + return "VkDataGraphOpticalFlowImageFormatInfoARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM: + return "VkDataGraphPipelineOpticalFlowDispatchInfoARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM: + return "VkDataGraphPipelineResourceInfoImageLayoutARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM: + return "VkDataGraphPipelineSingleNodeConnectionARM"; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM: + return "VkDataGraphPipelineSingleNodeCreateInfoARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: return "VkPhysicalDeviceShaderLongVectorFeaturesEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: diff --git a/scripts/known_good.json b/scripts/known_good.json index efd9cc0..643b1c7 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.348" + "commit": "v1.4.349" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 11524bf..8e1011c 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -2381,6 +2381,24 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: safe_pNext = new safe_VkPhysicalDeviceDataGraphModelFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM: + safe_pNext = new safe_VkDataGraphPipelineOpticalFlowCreateInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM: + safe_pNext = new safe_VkDataGraphOpticalFlowImageFormatInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM: + safe_pNext = new safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM: + safe_pNext = new safe_VkDataGraphPipelineResourceInfoImageLayoutARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM: + safe_pNext = new safe_VkDataGraphPipelineSingleNodeCreateInfoARM(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceShaderLongVectorFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -4802,6 +4820,24 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: delete reinterpret_cast(header); break; diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp index 305bc03..eb9b6c2 100644 --- a/src/vulkan/vk_safe_struct_vendor.cpp +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -24033,6 +24033,599 @@ void safe_VkPhysicalDeviceDataGraphModelFeaturesQCOM::initialize(const safe_VkPh pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM( + const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dataGraphOpticalFlow(in_struct->dataGraphOpticalFlow) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM), pNext(nullptr), dataGraphOpticalFlow() {} + +safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM( + const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& copy_src) { + sType = copy_src.sType; + dataGraphOpticalFlow = copy_src.dataGraphOpticalFlow; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::operator=( + const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dataGraphOpticalFlow = copy_src.dataGraphOpticalFlow; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::~safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::initialize( + const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dataGraphOpticalFlow = in_struct->dataGraphOpticalFlow; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::initialize( + const safe_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dataGraphOpticalFlow = copy_src->dataGraphOpticalFlow; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM( + const VkQueueFamilyDataGraphOpticalFlowPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + supportedOutputGridSizes(in_struct->supportedOutputGridSizes), + supportedHintGridSizes(in_struct->supportedHintGridSizes), + hintSupported(in_struct->hintSupported), + costSupported(in_struct->costSupported), + minWidth(in_struct->minWidth), + minHeight(in_struct->minHeight), + maxWidth(in_struct->maxWidth), + maxHeight(in_struct->maxHeight) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM), + pNext(nullptr), + supportedOutputGridSizes(), + supportedHintGridSizes(), + hintSupported(), + costSupported(), + minWidth(), + minHeight(), + maxWidth(), + maxHeight() {} + +safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM( + const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& copy_src) { + sType = copy_src.sType; + supportedOutputGridSizes = copy_src.supportedOutputGridSizes; + supportedHintGridSizes = copy_src.supportedHintGridSizes; + hintSupported = copy_src.hintSupported; + costSupported = copy_src.costSupported; + minWidth = copy_src.minWidth; + minHeight = copy_src.minHeight; + maxWidth = copy_src.maxWidth; + maxHeight = copy_src.maxHeight; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::operator=( + const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedOutputGridSizes = copy_src.supportedOutputGridSizes; + supportedHintGridSizes = copy_src.supportedHintGridSizes; + hintSupported = copy_src.hintSupported; + costSupported = copy_src.costSupported; + minWidth = copy_src.minWidth; + minHeight = copy_src.minHeight; + maxWidth = copy_src.maxWidth; + maxHeight = copy_src.maxHeight; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::~safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::initialize( + const VkQueueFamilyDataGraphOpticalFlowPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedOutputGridSizes = in_struct->supportedOutputGridSizes; + supportedHintGridSizes = in_struct->supportedHintGridSizes; + hintSupported = in_struct->hintSupported; + costSupported = in_struct->costSupported; + minWidth = in_struct->minWidth; + minHeight = in_struct->minHeight; + maxWidth = in_struct->maxWidth; + maxHeight = in_struct->maxHeight; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM::initialize( + const safe_VkQueueFamilyDataGraphOpticalFlowPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedOutputGridSizes = copy_src->supportedOutputGridSizes; + supportedHintGridSizes = copy_src->supportedHintGridSizes; + hintSupported = copy_src->hintSupported; + costSupported = copy_src->costSupported; + minWidth = copy_src->minWidth; + minHeight = copy_src->minHeight; + maxWidth = copy_src->maxWidth; + maxHeight = copy_src->maxHeight; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::safe_VkDataGraphPipelineOpticalFlowCreateInfoARM( + const VkDataGraphPipelineOpticalFlowCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + width(in_struct->width), + height(in_struct->height), + imageFormat(in_struct->imageFormat), + flowVectorFormat(in_struct->flowVectorFormat), + costFormat(in_struct->costFormat), + outputGridSize(in_struct->outputGridSize), + hintGridSize(in_struct->hintGridSize), + performanceLevel(in_struct->performanceLevel), + flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::safe_VkDataGraphPipelineOpticalFlowCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM), + pNext(nullptr), + width(), + height(), + imageFormat(), + flowVectorFormat(), + costFormat(), + outputGridSize(), + hintGridSize(), + performanceLevel(), + flags() {} + +safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::safe_VkDataGraphPipelineOpticalFlowCreateInfoARM( + const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& copy_src) { + sType = copy_src.sType; + width = copy_src.width; + height = copy_src.height; + imageFormat = copy_src.imageFormat; + flowVectorFormat = copy_src.flowVectorFormat; + costFormat = copy_src.costFormat; + outputGridSize = copy_src.outputGridSize; + hintGridSize = copy_src.hintGridSize; + performanceLevel = copy_src.performanceLevel; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::operator=( + const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + width = copy_src.width; + height = copy_src.height; + imageFormat = copy_src.imageFormat; + flowVectorFormat = copy_src.flowVectorFormat; + costFormat = copy_src.costFormat; + outputGridSize = copy_src.outputGridSize; + hintGridSize = copy_src.hintGridSize; + performanceLevel = copy_src.performanceLevel; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::~safe_VkDataGraphPipelineOpticalFlowCreateInfoARM() { FreePnextChain(pNext); } + +void safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::initialize(const VkDataGraphPipelineOpticalFlowCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + width = in_struct->width; + height = in_struct->height; + imageFormat = in_struct->imageFormat; + flowVectorFormat = in_struct->flowVectorFormat; + costFormat = in_struct->costFormat; + outputGridSize = in_struct->outputGridSize; + hintGridSize = in_struct->hintGridSize; + performanceLevel = in_struct->performanceLevel; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphPipelineOpticalFlowCreateInfoARM::initialize(const safe_VkDataGraphPipelineOpticalFlowCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + width = copy_src->width; + height = copy_src->height; + imageFormat = copy_src->imageFormat; + flowVectorFormat = copy_src->flowVectorFormat; + costFormat = copy_src->costFormat; + outputGridSize = copy_src->outputGridSize; + hintGridSize = copy_src->hintGridSize; + performanceLevel = copy_src->performanceLevel; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::safe_VkDataGraphOpticalFlowImageFormatPropertiesARM( + const VkDataGraphOpticalFlowImageFormatPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::safe_VkDataGraphOpticalFlowImageFormatPropertiesARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM), pNext(nullptr), format() {} + +safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::safe_VkDataGraphOpticalFlowImageFormatPropertiesARM( + const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::operator=( + const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::~safe_VkDataGraphOpticalFlowImageFormatPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::initialize( + const VkDataGraphOpticalFlowImageFormatPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphOpticalFlowImageFormatPropertiesARM::initialize( + const safe_VkDataGraphOpticalFlowImageFormatPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphOpticalFlowImageFormatInfoARM::safe_VkDataGraphOpticalFlowImageFormatInfoARM( + const VkDataGraphOpticalFlowImageFormatInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), usage(in_struct->usage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphOpticalFlowImageFormatInfoARM::safe_VkDataGraphOpticalFlowImageFormatInfoARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM), pNext(nullptr), usage() {} + +safe_VkDataGraphOpticalFlowImageFormatInfoARM::safe_VkDataGraphOpticalFlowImageFormatInfoARM( + const safe_VkDataGraphOpticalFlowImageFormatInfoARM& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphOpticalFlowImageFormatInfoARM& safe_VkDataGraphOpticalFlowImageFormatInfoARM::operator=( + const safe_VkDataGraphOpticalFlowImageFormatInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphOpticalFlowImageFormatInfoARM::~safe_VkDataGraphOpticalFlowImageFormatInfoARM() { FreePnextChain(pNext); } + +void safe_VkDataGraphOpticalFlowImageFormatInfoARM::initialize(const VkDataGraphOpticalFlowImageFormatInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphOpticalFlowImageFormatInfoARM::initialize(const safe_VkDataGraphOpticalFlowImageFormatInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM( + const VkDataGraphPipelineOpticalFlowDispatchInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), meanFlowL1NormHint(in_struct->meanFlowL1NormHint) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM), pNext(nullptr), flags(), meanFlowL1NormHint() {} + +safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM( + const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + meanFlowL1NormHint = copy_src.meanFlowL1NormHint; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::operator=( + const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + meanFlowL1NormHint = copy_src.meanFlowL1NormHint; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::~safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM() { FreePnextChain(pNext); } + +void safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::initialize(const VkDataGraphPipelineOpticalFlowDispatchInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + meanFlowL1NormHint = in_struct->meanFlowL1NormHint; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM::initialize( + const safe_VkDataGraphPipelineOpticalFlowDispatchInfoARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + meanFlowL1NormHint = copy_src->meanFlowL1NormHint; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphPipelineResourceInfoImageLayoutARM::safe_VkDataGraphPipelineResourceInfoImageLayoutARM( + const VkDataGraphPipelineResourceInfoImageLayoutARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), layout(in_struct->layout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphPipelineResourceInfoImageLayoutARM::safe_VkDataGraphPipelineResourceInfoImageLayoutARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM), pNext(nullptr), layout() {} + +safe_VkDataGraphPipelineResourceInfoImageLayoutARM::safe_VkDataGraphPipelineResourceInfoImageLayoutARM( + const safe_VkDataGraphPipelineResourceInfoImageLayoutARM& copy_src) { + sType = copy_src.sType; + layout = copy_src.layout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphPipelineResourceInfoImageLayoutARM& safe_VkDataGraphPipelineResourceInfoImageLayoutARM::operator=( + const safe_VkDataGraphPipelineResourceInfoImageLayoutARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + layout = copy_src.layout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphPipelineResourceInfoImageLayoutARM::~safe_VkDataGraphPipelineResourceInfoImageLayoutARM() { FreePnextChain(pNext); } + +void safe_VkDataGraphPipelineResourceInfoImageLayoutARM::initialize(const VkDataGraphPipelineResourceInfoImageLayoutARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + layout = in_struct->layout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphPipelineResourceInfoImageLayoutARM::initialize( + const safe_VkDataGraphPipelineResourceInfoImageLayoutARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + layout = copy_src->layout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphPipelineSingleNodeConnectionARM::safe_VkDataGraphPipelineSingleNodeConnectionARM( + const VkDataGraphPipelineSingleNodeConnectionARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), set(in_struct->set), binding(in_struct->binding), connection(in_struct->connection) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDataGraphPipelineSingleNodeConnectionARM::safe_VkDataGraphPipelineSingleNodeConnectionARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM), pNext(nullptr), set(), binding(), connection() {} + +safe_VkDataGraphPipelineSingleNodeConnectionARM::safe_VkDataGraphPipelineSingleNodeConnectionARM( + const safe_VkDataGraphPipelineSingleNodeConnectionARM& copy_src) { + sType = copy_src.sType; + set = copy_src.set; + binding = copy_src.binding; + connection = copy_src.connection; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDataGraphPipelineSingleNodeConnectionARM& safe_VkDataGraphPipelineSingleNodeConnectionARM::operator=( + const safe_VkDataGraphPipelineSingleNodeConnectionARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + set = copy_src.set; + binding = copy_src.binding; + connection = copy_src.connection; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDataGraphPipelineSingleNodeConnectionARM::~safe_VkDataGraphPipelineSingleNodeConnectionARM() { FreePnextChain(pNext); } + +void safe_VkDataGraphPipelineSingleNodeConnectionARM::initialize(const VkDataGraphPipelineSingleNodeConnectionARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + set = in_struct->set; + binding = in_struct->binding; + connection = in_struct->connection; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDataGraphPipelineSingleNodeConnectionARM::initialize(const safe_VkDataGraphPipelineSingleNodeConnectionARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + set = copy_src->set; + binding = copy_src->binding; + connection = copy_src->connection; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDataGraphPipelineSingleNodeCreateInfoARM::safe_VkDataGraphPipelineSingleNodeCreateInfoARM( + const VkDataGraphPipelineSingleNodeCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), nodeType(in_struct->nodeType), connectionCount(in_struct->connectionCount), pConnections(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (connectionCount && in_struct->pConnections) { + pConnections = new safe_VkDataGraphPipelineSingleNodeConnectionARM[connectionCount]; + for (uint32_t i = 0; i < connectionCount; ++i) { + pConnections[i].initialize(&in_struct->pConnections[i]); + } + } +} + +safe_VkDataGraphPipelineSingleNodeCreateInfoARM::safe_VkDataGraphPipelineSingleNodeCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM), + pNext(nullptr), + nodeType(), + connectionCount(), + pConnections(nullptr) {} + +safe_VkDataGraphPipelineSingleNodeCreateInfoARM::safe_VkDataGraphPipelineSingleNodeCreateInfoARM( + const safe_VkDataGraphPipelineSingleNodeCreateInfoARM& copy_src) { + sType = copy_src.sType; + nodeType = copy_src.nodeType; + connectionCount = copy_src.connectionCount; + pConnections = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (connectionCount && copy_src.pConnections) { + pConnections = new safe_VkDataGraphPipelineSingleNodeConnectionARM[connectionCount]; + for (uint32_t i = 0; i < connectionCount; ++i) { + pConnections[i].initialize(©_src.pConnections[i]); + } + } +} + +safe_VkDataGraphPipelineSingleNodeCreateInfoARM& safe_VkDataGraphPipelineSingleNodeCreateInfoARM::operator=( + const safe_VkDataGraphPipelineSingleNodeCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pConnections) delete[] pConnections; + FreePnextChain(pNext); + + sType = copy_src.sType; + nodeType = copy_src.nodeType; + connectionCount = copy_src.connectionCount; + pConnections = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (connectionCount && copy_src.pConnections) { + pConnections = new safe_VkDataGraphPipelineSingleNodeConnectionARM[connectionCount]; + for (uint32_t i = 0; i < connectionCount; ++i) { + pConnections[i].initialize(©_src.pConnections[i]); + } + } + + return *this; +} + +safe_VkDataGraphPipelineSingleNodeCreateInfoARM::~safe_VkDataGraphPipelineSingleNodeCreateInfoARM() { + if (pConnections) delete[] pConnections; + FreePnextChain(pNext); +} + +void safe_VkDataGraphPipelineSingleNodeCreateInfoARM::initialize(const VkDataGraphPipelineSingleNodeCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pConnections) delete[] pConnections; + FreePnextChain(pNext); + sType = in_struct->sType; + nodeType = in_struct->nodeType; + connectionCount = in_struct->connectionCount; + pConnections = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (connectionCount && in_struct->pConnections) { + pConnections = new safe_VkDataGraphPipelineSingleNodeConnectionARM[connectionCount]; + for (uint32_t i = 0; i < connectionCount; ++i) { + pConnections[i].initialize(&in_struct->pConnections[i]); + } + } +} + +void safe_VkDataGraphPipelineSingleNodeCreateInfoARM::initialize(const safe_VkDataGraphPipelineSingleNodeCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + nodeType = copy_src->nodeType; + connectionCount = copy_src->connectionCount; + pConnections = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (connectionCount && copy_src->pConnections) { + pConnections = new safe_VkDataGraphPipelineSingleNodeConnectionARM[connectionCount]; + for (uint32_t i = 0; i < connectionCount; ++i) { + pConnections[i].initialize(©_src->pConnections[i]); + } + } +} + safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::safe_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)