Skip to content

Commit ead516b

Browse files
mikes-lunargcharles-lunarg
mikes-lunarg
authored and
charles-lunarg
committed
scripts: Vulkaninfo video codegen now uses vendor extensions
vulkaninfo typically excludes vendor extensions, but video extensions are excluded from this. The extension categories struct definitions now have a new member 'ignore_vendor_exclusions' to control whether that category include vendor extensions.
1 parent 0e15c62 commit ead516b

File tree

2 files changed

+156
-10
lines changed

2 files changed

+156
-10
lines changed

‎scripts/vulkaninfo_generator.py‎

Lines changed: 24 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -119,56 +119,65 @@
119119
'type': EXTENSION_TYPE_BOTH,
120120
'holder_type': 'VkPhysicalDeviceProperties2',
121121
'print_iterator': True,
122-
'can_show_promoted_structs': True}),
122+
'can_show_promoted_structs': True,
123+
'ignore_vendor_exclusion': False}),
123124
('phys_device_mem_props2',
124125
{'extends': 'VkPhysicalDeviceMemoryProperties2',
125126
'type': EXTENSION_TYPE_DEVICE,
126127
'holder_type':'VkPhysicalDeviceMemoryProperties2',
127128
'print_iterator': False,
128-
'can_show_promoted_structs': False}),
129+
'can_show_promoted_structs': False,
130+
'ignore_vendor_exclusion': False}),
129131
('phys_device_features2',
130132
{'extends': 'VkPhysicalDeviceFeatures2,VkDeviceCreateInfo',
131133
'type': EXTENSION_TYPE_DEVICE,
132134
'holder_type': 'VkPhysicalDeviceFeatures2',
133135
'print_iterator': True,
134-
'can_show_promoted_structs': True}),
136+
'can_show_promoted_structs': True,
137+
'ignore_vendor_exclusion': False}),
135138
('surface_capabilities2',
136139
{'extends': 'VkSurfaceCapabilities2KHR',
137140
'type': EXTENSION_TYPE_BOTH,
138141
'holder_type': 'VkSurfaceCapabilities2KHR',
139142
'print_iterator': True,
140143
'can_show_promoted_structs': False,
144+
'ignore_vendor_exclusion': False,
141145
'exclude': ['VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR']}),
142146
('format_properties2',
143147
{'extends': 'VkFormatProperties2',
144148
'type': EXTENSION_TYPE_DEVICE,
145149
'holder_type':'VkFormatProperties2',
146150
'print_iterator': True,
147-
'can_show_promoted_structs': False}),
151+
'can_show_promoted_structs': False,
152+
'ignore_vendor_exclusion': False}),
148153
('queue_properties2',
149154
{'extends': 'VkQueueFamilyProperties2',
150155
'type': EXTENSION_TYPE_DEVICE,
151156
'holder_type': 'VkQueueFamilyProperties2',
152157
'print_iterator': True,
153-
'can_show_promoted_structs': False}),
158+
'can_show_promoted_structs': False,
159+
'ignore_vendor_exclusion': False}),
154160
('video_profile_info',
155161
{'extends': 'VkVideoProfileInfoKHR',
156162
'type': EXTENSION_TYPE_DEVICE,
157163
'holder_type': 'VkVideoProfileInfoKHR',
158164
'print_iterator': True,
159-
'can_show_promoted_structs': False}),
165+
'can_show_promoted_structs': False,
166+
'ignore_vendor_exclusion': True}),
160167
('video_capabilities',
161168
{'extends': 'VkVideoCapabilitiesKHR',
162169
'type': EXTENSION_TYPE_DEVICE,
163170
'holder_type': 'VkVideoCapabilitiesKHR',
164171
'print_iterator': True,
165-
'can_show_promoted_structs': False}),
172+
'can_show_promoted_structs': False,
173+
'ignore_vendor_exclusion': True,}),
166174
('video_format_properties',
167175
{'extends': 'VkVideoFormatPropertiesKHR',
168176
'type': EXTENSION_TYPE_DEVICE,
169177
'holder_type': 'VkVideoFormatPropertiesKHR',
170178
'print_iterator': True,
171-
'can_show_promoted_structs': False})
179+
'can_show_promoted_structs': False,
180+
'ignore_vendor_exclusion': True})
172181
))
173182
class VulkanInfoGeneratorOptions(GeneratorOptions):
174183
def __init__(self,
@@ -856,16 +865,21 @@ def genType(self, typeinfo, name, alias):
856865
self.all_structures.append(VulkanStructure(
857866
name, typeinfo.elem, self.constants, self.extTypes))
858867

868+
is_vendor_type = False
859869
for vendor in self.vendor_abbreviations:
860870
for node in typeinfo.elem.findall('member'):
861871
if node.get('values') is not None:
862872
if node.get('values').find(vendor) != -1:
863-
return
873+
is_vendor_type = True
874+
break
875+
if is_vendor_type:
876+
break
864877

865878
for key, value in EXTENSION_CATEGORIES.items():
866879
if str(typeinfo.elem.get('structextends')).find(value.get('extends')) != -1:
867880
if value.get('exclude') is None or name not in value.get('exclude'):
868-
self.extension_sets[key].add(name)
881+
if not is_vendor_type or value.get('ignore_vendor_exclusion'):
882+
self.extension_sets[key].add(name)
869883

870884
# finds all the ranges of formats from core (1.0), core versions (1.1+), and extensions
871885
def findFormatRanges(self):

‎vulkaninfo/generated/vulkaninfo.hpp‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2910,6 +2910,108 @@ void DumpVkVideoEncodeRateControlModeFlagBitsKHR(Printer &p, std::string name, V
29102910
}
29112911
}
29122912

2913+
std::vector<const char *> VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
2914+
std::vector<const char *> strings;
2915+
if (value == 0) { strings.push_back("None"); return strings; }
2916+
if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE");
2917+
if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE");
2918+
return strings;
2919+
}
2920+
void DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagsVALVE value) {
2921+
if (static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value) == 0) {
2922+
ArrayWrapper arr(p, name, 0);
2923+
if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output)
2924+
p.SetAsType().PrintString("None");
2925+
return;
2926+
}
2927+
auto strings = VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value));
2928+
ArrayWrapper arr(p, name, strings.size());
2929+
for(auto& str : strings){
2930+
if (p.Type() == OutputType::json)
2931+
p.SetAsType().PrintString(std::string("VK_") + str);
2932+
else
2933+
p.SetAsType().PrintString(str);
2934+
}
2935+
}
2936+
void DumpVkVideoEncodeRgbChromaOffsetFlagBitsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
2937+
auto strings = VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(value);
2938+
if (strings.size() > 0) {
2939+
if (p.Type() == OutputType::json)
2940+
p.PrintKeyString(name, std::string("VK_") + strings.at(0));
2941+
else
2942+
p.PrintKeyString(name, strings.at(0));
2943+
}
2944+
}
2945+
2946+
std::vector<const char *> VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
2947+
std::vector<const char *> strings;
2948+
if (value == 0) { strings.push_back("None"); return strings; }
2949+
if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE");
2950+
if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE");
2951+
if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE");
2952+
if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE");
2953+
if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE");
2954+
return strings;
2955+
}
2956+
void DumpVkVideoEncodeRgbModelConversionFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbModelConversionFlagsVALVE value) {
2957+
if (static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value) == 0) {
2958+
ArrayWrapper arr(p, name, 0);
2959+
if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output)
2960+
p.SetAsType().PrintString("None");
2961+
return;
2962+
}
2963+
auto strings = VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value));
2964+
ArrayWrapper arr(p, name, strings.size());
2965+
for(auto& str : strings){
2966+
if (p.Type() == OutputType::json)
2967+
p.SetAsType().PrintString(std::string("VK_") + str);
2968+
else
2969+
p.SetAsType().PrintString(str);
2970+
}
2971+
}
2972+
void DumpVkVideoEncodeRgbModelConversionFlagBitsVALVE(Printer &p, std::string name, VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
2973+
auto strings = VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(value);
2974+
if (strings.size() > 0) {
2975+
if (p.Type() == OutputType::json)
2976+
p.PrintKeyString(name, std::string("VK_") + strings.at(0));
2977+
else
2978+
p.PrintKeyString(name, strings.at(0));
2979+
}
2980+
}
2981+
2982+
std::vector<const char *> VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
2983+
std::vector<const char *> strings;
2984+
if (value == 0) { strings.push_back("None"); return strings; }
2985+
if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE");
2986+
if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE & value) strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE");
2987+
return strings;
2988+
}
2989+
void DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbRangeCompressionFlagsVALVE value) {
2990+
if (static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value) == 0) {
2991+
ArrayWrapper arr(p, name, 0);
2992+
if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output)
2993+
p.SetAsType().PrintString("None");
2994+
return;
2995+
}
2996+
auto strings = VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value));
2997+
ArrayWrapper arr(p, name, strings.size());
2998+
for(auto& str : strings){
2999+
if (p.Type() == OutputType::json)
3000+
p.SetAsType().PrintString(std::string("VK_") + str);
3001+
else
3002+
p.SetAsType().PrintString(str);
3003+
}
3004+
}
3005+
void DumpVkVideoEncodeRgbRangeCompressionFlagBitsVALVE(Printer &p, std::string name, VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
3006+
auto strings = VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(value);
3007+
if (strings.size() > 0) {
3008+
if (p.Type() == OutputType::json)
3009+
p.PrintKeyString(name, std::string("VK_") + strings.at(0));
3010+
else
3011+
p.PrintKeyString(name, strings.at(0));
3012+
}
3013+
}
3014+
29133015
std::vector<const char *> VkVideoEncodeUsageFlagBitsKHRGetStrings(VkVideoEncodeUsageFlagBitsKHR value) {
29143016
std::vector<const char *> strings;
29153017
if (value == 0) { strings.push_back("VIDEO_ENCODE_USAGE_DEFAULT_KHR"); return strings; }
@@ -5370,10 +5472,22 @@ void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer &p, std::string name,
53705472
p.PrintKeyBool("partitionIndependentIntraRefreshRegions", static_cast<bool>(obj.partitionIndependentIntraRefreshRegions));
53715473
p.PrintKeyBool("nonRectangularIntraRefreshRegions", static_cast<bool>(obj.nonRectangularIntraRefreshRegions));
53725474
}
5475+
void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer &p, std::string name, const VkVideoEncodeProfileRgbConversionInfoVALVE &obj) {
5476+
ObjectWrapper object{p, name};
5477+
p.SetMinKeyWidth(26);
5478+
p.PrintKeyBool("performEncodeRgbConversion", static_cast<bool>(obj.performEncodeRgbConversion));
5479+
}
53735480
void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeQuantizationMapCapabilitiesKHR &obj) {
53745481
ObjectWrapper object{p, name};
53755482
DumpVkExtent2D(p, "maxQuantizationMapExtent", obj.maxQuantizationMapExtent);
53765483
}
5484+
void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer &p, std::string name, const VkVideoEncodeRgbConversionCapabilitiesVALVE &obj) {
5485+
ObjectWrapper object{p, name};
5486+
DumpVkVideoEncodeRgbModelConversionFlagsVALVE(p, "rgbModels", obj.rgbModels);
5487+
DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(p, "rgbRanges", obj.rgbRanges);
5488+
DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "xChromaOffsets", obj.xChromaOffsets);
5489+
DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "yChromaOffsets", obj.yChromaOffsets);
5490+
}
53775491
void DumpVkVideoEncodeUsageInfoKHR(Printer &p, std::string name, const VkVideoEncodeUsageInfoKHR &obj) {
53785492
ObjectWrapper object{p, name};
53795493
DumpVkVideoEncodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints);
@@ -7894,6 +8008,7 @@ struct video_profile_info_chain {
78948008
VkVideoEncodeAV1ProfileInfoKHR VideoEncodeAV1ProfileInfoKHR{};
78958009
VkVideoEncodeH264ProfileInfoKHR VideoEncodeH264ProfileInfoKHR{};
78968010
VkVideoEncodeH265ProfileInfoKHR VideoEncodeH265ProfileInfoKHR{};
8011+
VkVideoEncodeProfileRgbConversionInfoVALVE VideoEncodeProfileRgbConversionInfoVALVE{};
78978012
VkVideoEncodeUsageInfoKHR VideoEncodeUsageInfoKHR{};
78988013
void initialize_chain(AppGpu &gpu ) noexcept {
78998014
VideoDecodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
@@ -7904,6 +8019,7 @@ struct video_profile_info_chain {
79048019
VideoEncodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
79058020
VideoEncodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
79068021
VideoEncodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
8022+
VideoEncodeProfileRgbConversionInfoVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE;
79078023
VideoEncodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
79088024
std::vector<VkBaseOutStructure*> chain_members{};
79098025
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
@@ -7922,6 +8038,8 @@ struct video_profile_info_chain {
79228038
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH264ProfileInfoKHR));
79238039
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME))
79248040
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeH265ProfileInfoKHR));
8041+
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
8042+
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeProfileRgbConversionInfoVALVE));
79258043
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME))
79268044
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeUsageInfoKHR));
79278045

@@ -7983,6 +8101,11 @@ void chain_iterator_video_profile_info(Printer &p, AppGpu &gpu, const void * pla
79838101
DumpVkVideoEncodeH265ProfileInfoKHR(p, "VkVideoEncodeH265ProfileInfoKHR", *props);
79848102
p.AddNewline();
79858103
}
8104+
if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE) {
8105+
const VkVideoEncodeProfileRgbConversionInfoVALVE* props = (const VkVideoEncodeProfileRgbConversionInfoVALVE*)structure;
8106+
DumpVkVideoEncodeProfileRgbConversionInfoVALVE(p, "VkVideoEncodeProfileRgbConversionInfoVALVE", *props);
8107+
p.AddNewline();
8108+
}
79868109
if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR) {
79878110
const VkVideoEncodeUsageInfoKHR* props = (const VkVideoEncodeUsageInfoKHR*)structure;
79888111
DumpVkVideoEncodeUsageInfoKHR(p, "VkVideoEncodeUsageInfoKHR", *props);
@@ -8017,6 +8140,7 @@ struct video_capabilities_chain {
80178140
VkVideoEncodeH265QuantizationMapCapabilitiesKHR VideoEncodeH265QuantizationMapCapabilitiesKHR{};
80188141
VkVideoEncodeIntraRefreshCapabilitiesKHR VideoEncodeIntraRefreshCapabilitiesKHR{};
80198142
VkVideoEncodeQuantizationMapCapabilitiesKHR VideoEncodeQuantizationMapCapabilitiesKHR{};
8143+
VkVideoEncodeRgbConversionCapabilitiesVALVE VideoEncodeRgbConversionCapabilitiesVALVE{};
80208144
void initialize_chain(AppGpu &gpu ) noexcept {
80218145
VideoDecodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
80228146
VideoDecodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
@@ -8032,6 +8156,7 @@ struct video_capabilities_chain {
80328156
VideoEncodeH265QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
80338157
VideoEncodeIntraRefreshCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
80348158
VideoEncodeQuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
8159+
VideoEncodeRgbConversionCapabilitiesVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
80358160
std::vector<VkBaseOutStructure*> chain_members{};
80368161
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
80378162
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoDecodeAV1CapabilitiesKHR));
@@ -8061,6 +8186,8 @@ struct video_capabilities_chain {
80618186
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeIntraRefreshCapabilitiesKHR));
80628187
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
80638188
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeQuantizationMapCapabilitiesKHR));
8189+
if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
8190+
chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&VideoEncodeRgbConversionCapabilitiesVALVE));
80648191

80658192
if (!chain_members.empty()) {
80668193
for(size_t i = 0; i < chain_members.size() - 1; i++){
@@ -8150,6 +8277,11 @@ void chain_iterator_video_capabilities(Printer &p, AppGpu &gpu, const void * pla
81508277
DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(p, "VkVideoEncodeQuantizationMapCapabilitiesKHR", *props);
81518278
p.AddNewline();
81528279
}
8280+
if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE) {
8281+
const VkVideoEncodeRgbConversionCapabilitiesVALVE* props = (const VkVideoEncodeRgbConversionCapabilitiesVALVE*)structure;
8282+
DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(p, "VkVideoEncodeRgbConversionCapabilitiesVALVE", *props);
8283+
p.AddNewline();
8284+
}
81538285
place = structure->pNext;
81548286
}
81558287
}

0 commit comments

Comments
 (0)