build: Update to header 1.4.327
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0784a14..2347f13 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.326 LANGUAGES CXX)
+project(VUL VERSION 1.4.327 LANGUAGES CXX)
set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index f3d849e..839fead 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -4133,7 +4133,7 @@
};
struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
VkStructureType sType;
- void* pNext{};
+ const void* pNext{};
uint32_t requiredSubgroupSize;
safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct,
@@ -16709,6 +16709,96 @@
return reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const*>(this);
}
};
+struct safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
+ VkStructureType sType;
+ void* pNext{};
+ VkBool32 videoEncodeRgbConversion;
+
+ safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(
+ const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, PNextCopyState* copy_state = {},
+ bool copy_pnext = true);
+ safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(
+ const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src);
+ safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& operator=(
+ const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src);
+ safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE();
+ ~safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE();
+ void initialize(const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* copy_src, PNextCopyState* copy_state = {});
+ VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* ptr() {
+ return reinterpret_cast<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(this);
+ }
+ VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const* ptr() const {
+ return reinterpret_cast<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const*>(this);
+ }
+};
+struct safe_VkVideoEncodeRgbConversionCapabilitiesVALVE {
+ VkStructureType sType;
+ void* pNext{};
+ VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels;
+ VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges;
+ VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets;
+ VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets;
+
+ safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src);
+ safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& operator=(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src);
+ safe_VkVideoEncodeRgbConversionCapabilitiesVALVE();
+ ~safe_VkVideoEncodeRgbConversionCapabilitiesVALVE();
+ void initialize(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeRgbConversionCapabilitiesVALVE* ptr() {
+ return reinterpret_cast<VkVideoEncodeRgbConversionCapabilitiesVALVE*>(this);
+ }
+ VkVideoEncodeRgbConversionCapabilitiesVALVE const* ptr() const {
+ return reinterpret_cast<VkVideoEncodeRgbConversionCapabilitiesVALVE const*>(this);
+ }
+};
+struct safe_VkVideoEncodeProfileRgbConversionInfoVALVE {
+ VkStructureType sType;
+ const void* pNext{};
+ VkBool32 performEncodeRgbConversion;
+
+ safe_VkVideoEncodeProfileRgbConversionInfoVALVE(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkVideoEncodeProfileRgbConversionInfoVALVE(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src);
+ safe_VkVideoEncodeProfileRgbConversionInfoVALVE& operator=(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src);
+ safe_VkVideoEncodeProfileRgbConversionInfoVALVE();
+ ~safe_VkVideoEncodeProfileRgbConversionInfoVALVE();
+ void initialize(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeProfileRgbConversionInfoVALVE* ptr() {
+ return reinterpret_cast<VkVideoEncodeProfileRgbConversionInfoVALVE*>(this);
+ }
+ VkVideoEncodeProfileRgbConversionInfoVALVE const* ptr() const {
+ return reinterpret_cast<VkVideoEncodeProfileRgbConversionInfoVALVE const*>(this);
+ }
+};
+struct safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
+ VkStructureType sType;
+ const void* pNext{};
+ VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel;
+ VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange;
+ VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset;
+ VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset;
+
+ safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct,
+ PNextCopyState* copy_state = {}, bool copy_pnext = true);
+ safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src);
+ safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& operator=(
+ const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src);
+ safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE();
+ ~safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE();
+ void initialize(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, PNextCopyState* copy_state = {});
+ void initialize(const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE* copy_src, PNextCopyState* copy_state = {});
+ VkVideoEncodeSessionRgbConversionCreateInfoVALVE* ptr() {
+ return reinterpret_cast<VkVideoEncodeSessionRgbConversionCreateInfoVALVE*>(this);
+ }
+ VkVideoEncodeSessionRgbConversionCreateInfoVALVE const* ptr() const {
+ return reinterpret_cast<VkVideoEncodeSessionRgbConversionCreateInfoVALVE const*>(this);
+ }
+};
struct safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT {
VkStructureType sType;
void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index a2d5fb4..81e579c 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -882,6 +882,10 @@
template <> inline VkStructureType GetSType<VkPhysicalDeviceColorWriteEnableFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPipelineColorWriteCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; }
+template <> inline VkStructureType GetSType<VkVideoEncodeRgbConversionCapabilitiesVALVE>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; }
+template <> inline VkStructureType GetSType<VkVideoEncodeProfileRgbConversionInfoVALVE>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; }
+template <> inline VkStructureType GetSType<VkVideoEncodeSessionRgbConversionCreateInfoVALVE>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceImageViewMinLodFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkImageViewMinLodCreateInfoEXT>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiDrawFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 853bd15..601a78d 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1612,6 +1612,14 @@
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
+ return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT";
case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
@@ -10228,6 +10236,93 @@
return ret;
}
#endif // __cplusplus
+static inline const char* string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(VkVideoEncodeRgbModelConversionFlagBitsVALVE input_value) {
+ switch (input_value) {
+ case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE";
+ default:
+ return "Unhandled VkVideoEncodeRgbModelConversionFlagBitsVALVE";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeRgbModelConversionFlagsVALVE(VkVideoEncodeRgbModelConversionFlagsVALVE input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkVideoEncodeRgbModelConversionFlagsVALVE(0)");
+ return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(VkVideoEncodeRgbRangeCompressionFlagBitsVALVE input_value) {
+ switch (input_value) {
+ case VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE";
+ default:
+ return "Unhandled VkVideoEncodeRgbRangeCompressionFlagBitsVALVE";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeRgbRangeCompressionFlagsVALVE(VkVideoEncodeRgbRangeCompressionFlagsVALVE input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkVideoEncodeRgbRangeCompressionFlagsVALVE(0)");
+ return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE input_value) {
+ switch (input_value) {
+ case VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE";
+ case VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE:
+ return "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE";
+ default:
+ return "Unhandled VkVideoEncodeRgbChromaOffsetFlagBitsVALVE";
+ }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeRgbChromaOffsetFlagsVALVE(VkVideoEncodeRgbChromaOffsetFlagsVALVE input_value) {
+ std::string ret;
+ int index = 0;
+ while(input_value) {
+ if (input_value & 1) {
+ if( !ret.empty()) ret.append("|");
+ ret.append(string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(1U << index)));
+ }
+ ++index;
+ input_value >>= 1;
+ }
+ if (ret.empty()) ret.append("VkVideoEncodeRgbChromaOffsetFlagsVALVE(0)");
+ return ret;
+}
+#endif // __cplusplus
static inline const char* string_VkBuildMicromapFlagBitsEXT(VkBuildMicromapFlagBitsEXT input_value) {
switch (input_value) {
case VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT:
@@ -12498,6 +12593,14 @@
return "VkPipelineColorWriteCreateInfoEXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
return "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+ return "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+ return "VkVideoEncodeRgbConversionCapabilitiesVALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
+ return "VkVideoEncodeProfileRgbConversionInfoVALVE";
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
+ return "VkVideoEncodeSessionRgbConversionCreateInfoVALVE";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
return "VkPhysicalDeviceImageViewMinLodFeaturesEXT";
case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 0647ae4..e8ca36c 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.326"
+ "commit": "v1.4.327"
},
{
"name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index b0824cc..6a782b5 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1668,6 +1668,18 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(pNext), copy_state, false);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+ safe_pNext = new safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+ safe_pNext = new safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
+ safe_pNext = new safe_VkVideoEncodeProfileRgbConversionInfoVALVE(reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE *>(pNext), copy_state, false);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
+ safe_pNext = new safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE *>(pNext), copy_state, false);
+ break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(pNext), copy_state, false);
break;
@@ -3898,6 +3910,18 @@
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+ delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+ delete reinterpret_cast<safe_VkVideoEncodeRgbConversionCapabilitiesVALVE *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
+ delete reinterpret_cast<safe_VkVideoEncodeProfileRgbConversionInfoVALVE *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
+ delete reinterpret_cast<safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE *>(header);
+ break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 1c25bfa..608807e 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -10494,6 +10494,247 @@
window = copy_src->window;
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
+
+safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(
+ const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+ bool copy_pnext)
+ : sType(in_struct->sType), videoEncodeRgbConversion(in_struct->videoEncodeRgbConversion) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE()
+ : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE),
+ pNext(nullptr),
+ videoEncodeRgbConversion() {}
+
+safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(
+ const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src) {
+ sType = copy_src.sType;
+ videoEncodeRgbConversion = copy_src.videoEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::operator=(
+ const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ videoEncodeRgbConversion = copy_src.videoEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::~safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::initialize(
+ const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ videoEncodeRgbConversion = in_struct->videoEncodeRgbConversion;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::initialize(
+ const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ videoEncodeRgbConversion = copy_src->videoEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(
+ const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType),
+ rgbModels(in_struct->rgbModels),
+ rgbRanges(in_struct->rgbRanges),
+ xChromaOffsets(in_struct->xChromaOffsets),
+ yChromaOffsets(in_struct->yChromaOffsets) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE),
+ pNext(nullptr),
+ rgbModels(),
+ rgbRanges(),
+ xChromaOffsets(),
+ yChromaOffsets() {}
+
+safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(
+ const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src) {
+ sType = copy_src.sType;
+ rgbModels = copy_src.rgbModels;
+ rgbRanges = copy_src.rgbRanges;
+ xChromaOffsets = copy_src.xChromaOffsets;
+ yChromaOffsets = copy_src.yChromaOffsets;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::operator=(
+ const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ rgbModels = copy_src.rgbModels;
+ rgbRanges = copy_src.rgbRanges;
+ xChromaOffsets = copy_src.xChromaOffsets;
+ yChromaOffsets = copy_src.yChromaOffsets;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::~safe_VkVideoEncodeRgbConversionCapabilitiesVALVE() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::initialize(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ rgbModels = in_struct->rgbModels;
+ rgbRanges = in_struct->rgbRanges;
+ xChromaOffsets = in_struct->xChromaOffsets;
+ yChromaOffsets = in_struct->yChromaOffsets;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::initialize(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ rgbModels = copy_src->rgbModels;
+ rgbRanges = copy_src->rgbRanges;
+ xChromaOffsets = copy_src->xChromaOffsets;
+ yChromaOffsets = copy_src->yChromaOffsets;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE(
+ const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType), performEncodeRgbConversion(in_struct->performEncodeRgbConversion) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE), pNext(nullptr), performEncodeRgbConversion() {}
+
+safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE(
+ const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src) {
+ sType = copy_src.sType;
+ performEncodeRgbConversion = copy_src.performEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeProfileRgbConversionInfoVALVE& safe_VkVideoEncodeProfileRgbConversionInfoVALVE::operator=(
+ const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ performEncodeRgbConversion = copy_src.performEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeProfileRgbConversionInfoVALVE::~safe_VkVideoEncodeProfileRgbConversionInfoVALVE() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeProfileRgbConversionInfoVALVE::initialize(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ performEncodeRgbConversion = in_struct->performEncodeRgbConversion;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeProfileRgbConversionInfoVALVE::initialize(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE* copy_src,
+ [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ performEncodeRgbConversion = copy_src->performEncodeRgbConversion;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(
+ const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+ : sType(in_struct->sType),
+ rgbModel(in_struct->rgbModel),
+ rgbRange(in_struct->rgbRange),
+ xChromaOffset(in_struct->xChromaOffset),
+ yChromaOffset(in_struct->yChromaOffset) {
+ if (copy_pnext) {
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+ }
+}
+
+safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE()
+ : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE),
+ pNext(nullptr),
+ rgbModel(),
+ rgbRange(),
+ xChromaOffset(),
+ yChromaOffset() {}
+
+safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(
+ const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src) {
+ sType = copy_src.sType;
+ rgbModel = copy_src.rgbModel;
+ rgbRange = copy_src.rgbRange;
+ xChromaOffset = copy_src.xChromaOffset;
+ yChromaOffset = copy_src.yChromaOffset;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::operator=(
+ const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src) {
+ if (©_src == this) return *this;
+
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ rgbModel = copy_src.rgbModel;
+ rgbRange = copy_src.rgbRange;
+ xChromaOffset = copy_src.xChromaOffset;
+ yChromaOffset = copy_src.yChromaOffset;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::~safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE() {
+ FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::initialize(
+ const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+ FreePnextChain(pNext);
+ sType = in_struct->sType;
+ rgbModel = in_struct->rgbModel;
+ rgbRange = in_struct->rgbRange;
+ xChromaOffset = in_struct->xChromaOffset;
+ yChromaOffset = in_struct->yChromaOffset;
+ pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::initialize(
+ const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+ sType = copy_src->sType;
+ rgbModel = copy_src->rgbModel;
+ rgbRange = copy_src->rgbRange;
+ xChromaOffset = copy_src->xChromaOffset;
+ yChromaOffset = copy_src->yChromaOffset;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
#ifdef VK_ENABLE_BETA_EXTENSIONS
safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
