1 // This file is auto-generated by vulkano autogen from vk.xml header version 1.3.238.
2 // It should not be edited manually. Changes should be made by editing autogen.
3
check_spirv_capability( device: &Device, capability: Capability, ) -> Result<(), ShaderSupportError>4 fn check_spirv_capability(
5 device: &Device,
6 capability: Capability,
7 ) -> Result<(), ShaderSupportError> {
8 match capability {
9 Capability::Matrix => (),
10 Capability::Shader => (),
11 Capability::InputAttachment => (),
12 Capability::Sampled1D => (),
13 Capability::Image1D => (),
14 Capability::SampledBuffer => (),
15 Capability::ImageBuffer => (),
16 Capability::ImageQuery => (),
17 Capability::DerivativeControl => (),
18 Capability::Geometry => {
19 if !(device.enabled_features().geometry_shader) {
20 return Err(ShaderSupportError::RequirementsNotMet(&[
21 "feature `geometry_shader`",
22 ]));
23 }
24 }
25 Capability::Tessellation => {
26 if !(device.enabled_features().tessellation_shader) {
27 return Err(ShaderSupportError::RequirementsNotMet(&[
28 "feature `tessellation_shader`",
29 ]));
30 }
31 }
32 Capability::Float64 => {
33 if !(device.enabled_features().shader_float64) {
34 return Err(ShaderSupportError::RequirementsNotMet(&[
35 "feature `shader_float64`",
36 ]));
37 }
38 }
39 Capability::Int64 => {
40 if !(device.enabled_features().shader_int64) {
41 return Err(ShaderSupportError::RequirementsNotMet(&[
42 "feature `shader_int64`",
43 ]));
44 }
45 }
46 Capability::Int64Atomics => {
47 if !(device.enabled_features().shader_buffer_int64_atomics
48 || device.enabled_features().shader_shared_int64_atomics
49 || device.enabled_features().shader_image_int64_atomics)
50 {
51 return Err(ShaderSupportError::RequirementsNotMet(&[
52 "feature `shader_buffer_int64_atomics`",
53 "feature `shader_shared_int64_atomics`",
54 "feature `shader_image_int64_atomics`",
55 ]));
56 }
57 }
58 Capability::AtomicFloat16AddEXT => {
59 if !(device.enabled_features().shader_buffer_float16_atomic_add
60 || device.enabled_features().shader_shared_float16_atomic_add)
61 {
62 return Err(ShaderSupportError::RequirementsNotMet(&[
63 "feature `shader_buffer_float16_atomic_add`",
64 "feature `shader_shared_float16_atomic_add`",
65 ]));
66 }
67 }
68 Capability::AtomicFloat32AddEXT => {
69 if !(device.enabled_features().shader_buffer_float32_atomic_add
70 || device.enabled_features().shader_shared_float32_atomic_add
71 || device.enabled_features().shader_image_float32_atomic_add)
72 {
73 return Err(ShaderSupportError::RequirementsNotMet(&[
74 "feature `shader_buffer_float32_atomic_add`",
75 "feature `shader_shared_float32_atomic_add`",
76 "feature `shader_image_float32_atomic_add`",
77 ]));
78 }
79 }
80 Capability::AtomicFloat64AddEXT => {
81 if !(device.enabled_features().shader_buffer_float64_atomic_add
82 || device.enabled_features().shader_shared_float64_atomic_add)
83 {
84 return Err(ShaderSupportError::RequirementsNotMet(&[
85 "feature `shader_buffer_float64_atomic_add`",
86 "feature `shader_shared_float64_atomic_add`",
87 ]));
88 }
89 }
90 Capability::AtomicFloat16MinMaxEXT => {
91 if !(device
92 .enabled_features()
93 .shader_buffer_float16_atomic_min_max
94 || device
95 .enabled_features()
96 .shader_shared_float16_atomic_min_max)
97 {
98 return Err(ShaderSupportError::RequirementsNotMet(&[
99 "feature `shader_buffer_float16_atomic_min_max`",
100 "feature `shader_shared_float16_atomic_min_max`",
101 ]));
102 }
103 }
104 Capability::AtomicFloat32MinMaxEXT => {
105 if !(device
106 .enabled_features()
107 .shader_buffer_float32_atomic_min_max
108 || device
109 .enabled_features()
110 .shader_shared_float32_atomic_min_max
111 || device
112 .enabled_features()
113 .shader_image_float32_atomic_min_max)
114 {
115 return Err(ShaderSupportError::RequirementsNotMet(&[
116 "feature `shader_buffer_float32_atomic_min_max`",
117 "feature `shader_shared_float32_atomic_min_max`",
118 "feature `shader_image_float32_atomic_min_max`",
119 ]));
120 }
121 }
122 Capability::AtomicFloat64MinMaxEXT => {
123 if !(device
124 .enabled_features()
125 .shader_buffer_float64_atomic_min_max
126 || device
127 .enabled_features()
128 .shader_shared_float64_atomic_min_max)
129 {
130 return Err(ShaderSupportError::RequirementsNotMet(&[
131 "feature `shader_buffer_float64_atomic_min_max`",
132 "feature `shader_shared_float64_atomic_min_max`",
133 ]));
134 }
135 }
136 Capability::Int64ImageEXT => {
137 if !(device.enabled_features().shader_image_int64_atomics) {
138 return Err(ShaderSupportError::RequirementsNotMet(&[
139 "feature `shader_image_int64_atomics`",
140 ]));
141 }
142 }
143 Capability::Int16 => {
144 if !(device.enabled_features().shader_int16) {
145 return Err(ShaderSupportError::RequirementsNotMet(&[
146 "feature `shader_int16`",
147 ]));
148 }
149 }
150 Capability::TessellationPointSize => {
151 if !(device
152 .enabled_features()
153 .shader_tessellation_and_geometry_point_size)
154 {
155 return Err(ShaderSupportError::RequirementsNotMet(&[
156 "feature `shader_tessellation_and_geometry_point_size`",
157 ]));
158 }
159 }
160 Capability::GeometryPointSize => {
161 if !(device
162 .enabled_features()
163 .shader_tessellation_and_geometry_point_size)
164 {
165 return Err(ShaderSupportError::RequirementsNotMet(&[
166 "feature `shader_tessellation_and_geometry_point_size`",
167 ]));
168 }
169 }
170 Capability::ImageGatherExtended => {
171 if !(device.enabled_features().shader_image_gather_extended) {
172 return Err(ShaderSupportError::RequirementsNotMet(&[
173 "feature `shader_image_gather_extended`",
174 ]));
175 }
176 }
177 Capability::StorageImageMultisample => {
178 if !(device.enabled_features().shader_storage_image_multisample) {
179 return Err(ShaderSupportError::RequirementsNotMet(&[
180 "feature `shader_storage_image_multisample`",
181 ]));
182 }
183 }
184 Capability::UniformBufferArrayDynamicIndexing => {
185 if !(device
186 .enabled_features()
187 .shader_uniform_buffer_array_dynamic_indexing)
188 {
189 return Err(ShaderSupportError::RequirementsNotMet(&[
190 "feature `shader_uniform_buffer_array_dynamic_indexing`",
191 ]));
192 }
193 }
194 Capability::SampledImageArrayDynamicIndexing => {
195 if !(device
196 .enabled_features()
197 .shader_sampled_image_array_dynamic_indexing)
198 {
199 return Err(ShaderSupportError::RequirementsNotMet(&[
200 "feature `shader_sampled_image_array_dynamic_indexing`",
201 ]));
202 }
203 }
204 Capability::StorageBufferArrayDynamicIndexing => {
205 if !(device
206 .enabled_features()
207 .shader_storage_buffer_array_dynamic_indexing)
208 {
209 return Err(ShaderSupportError::RequirementsNotMet(&[
210 "feature `shader_storage_buffer_array_dynamic_indexing`",
211 ]));
212 }
213 }
214 Capability::StorageImageArrayDynamicIndexing => {
215 if !(device
216 .enabled_features()
217 .shader_storage_image_array_dynamic_indexing)
218 {
219 return Err(ShaderSupportError::RequirementsNotMet(&[
220 "feature `shader_storage_image_array_dynamic_indexing`",
221 ]));
222 }
223 }
224 Capability::ClipDistance => {
225 if !(device.enabled_features().shader_clip_distance) {
226 return Err(ShaderSupportError::RequirementsNotMet(&[
227 "feature `shader_clip_distance`",
228 ]));
229 }
230 }
231 Capability::CullDistance => {
232 if !(device.enabled_features().shader_cull_distance) {
233 return Err(ShaderSupportError::RequirementsNotMet(&[
234 "feature `shader_cull_distance`",
235 ]));
236 }
237 }
238 Capability::ImageCubeArray => {
239 if !(device.enabled_features().image_cube_array) {
240 return Err(ShaderSupportError::RequirementsNotMet(&[
241 "feature `image_cube_array`",
242 ]));
243 }
244 }
245 Capability::SampleRateShading => {
246 if !(device.enabled_features().sample_rate_shading) {
247 return Err(ShaderSupportError::RequirementsNotMet(&[
248 "feature `sample_rate_shading`",
249 ]));
250 }
251 }
252 Capability::SparseResidency => {
253 if !(device.enabled_features().shader_resource_residency) {
254 return Err(ShaderSupportError::RequirementsNotMet(&[
255 "feature `shader_resource_residency`",
256 ]));
257 }
258 }
259 Capability::MinLod => {
260 if !(device.enabled_features().shader_resource_min_lod) {
261 return Err(ShaderSupportError::RequirementsNotMet(&[
262 "feature `shader_resource_min_lod`",
263 ]));
264 }
265 }
266 Capability::SampledCubeArray => {
267 if !(device.enabled_features().image_cube_array) {
268 return Err(ShaderSupportError::RequirementsNotMet(&[
269 "feature `image_cube_array`",
270 ]));
271 }
272 }
273 Capability::ImageMSArray => {
274 if !(device.enabled_features().shader_storage_image_multisample) {
275 return Err(ShaderSupportError::RequirementsNotMet(&[
276 "feature `shader_storage_image_multisample`",
277 ]));
278 }
279 }
280 Capability::StorageImageExtendedFormats => (),
281 Capability::InterpolationFunction => {
282 if !(device.enabled_features().sample_rate_shading) {
283 return Err(ShaderSupportError::RequirementsNotMet(&[
284 "feature `sample_rate_shading`",
285 ]));
286 }
287 }
288 Capability::StorageImageReadWithoutFormat => {
289 if !(device
290 .enabled_features()
291 .shader_storage_image_read_without_format
292 || device.api_version() >= Version::V1_1
293 || device.enabled_extensions().khr_format_feature_flags2)
294 {
295 return Err(ShaderSupportError::RequirementsNotMet(&[
296 "feature `shader_storage_image_read_without_format`",
297 "Vulkan API version 1.1",
298 "device extension `khr_format_feature_flags2`",
299 ]));
300 }
301 }
302 Capability::StorageImageWriteWithoutFormat => {
303 if !(device
304 .enabled_features()
305 .shader_storage_image_write_without_format
306 || device.api_version() >= Version::V1_1
307 || device.enabled_extensions().khr_format_feature_flags2)
308 {
309 return Err(ShaderSupportError::RequirementsNotMet(&[
310 "feature `shader_storage_image_write_without_format`",
311 "Vulkan API version 1.1",
312 "device extension `khr_format_feature_flags2`",
313 ]));
314 }
315 }
316 Capability::MultiViewport => {
317 if !(device.enabled_features().multi_viewport) {
318 return Err(ShaderSupportError::RequirementsNotMet(&[
319 "feature `multi_viewport`",
320 ]));
321 }
322 }
323 Capability::DrawParameters => {
324 if !(device.enabled_features().shader_draw_parameters
325 || device.enabled_extensions().khr_shader_draw_parameters)
326 {
327 return Err(ShaderSupportError::RequirementsNotMet(&[
328 "feature `shader_draw_parameters`",
329 "device extension `khr_shader_draw_parameters`",
330 ]));
331 }
332 }
333 Capability::MultiView => {
334 if !(device.enabled_features().multiview) {
335 return Err(ShaderSupportError::RequirementsNotMet(&[
336 "feature `multiview`",
337 ]));
338 }
339 }
340 Capability::DeviceGroup => {
341 if !(device.api_version() >= Version::V1_1
342 || device.enabled_extensions().khr_device_group)
343 {
344 return Err(ShaderSupportError::RequirementsNotMet(&[
345 "Vulkan API version 1.1",
346 "device extension `khr_device_group`",
347 ]));
348 }
349 }
350 Capability::VariablePointersStorageBuffer => {
351 if !(device.enabled_features().variable_pointers_storage_buffer) {
352 return Err(ShaderSupportError::RequirementsNotMet(&[
353 "feature `variable_pointers_storage_buffer`",
354 ]));
355 }
356 }
357 Capability::VariablePointers => {
358 if !(device.enabled_features().variable_pointers) {
359 return Err(ShaderSupportError::RequirementsNotMet(&[
360 "feature `variable_pointers`",
361 ]));
362 }
363 }
364 Capability::ShaderClockKHR => {
365 if !(device.enabled_extensions().khr_shader_clock) {
366 return Err(ShaderSupportError::RequirementsNotMet(&[
367 "device extension `khr_shader_clock`",
368 ]));
369 }
370 }
371 Capability::StencilExportEXT => {
372 if !(device.enabled_extensions().ext_shader_stencil_export) {
373 return Err(ShaderSupportError::RequirementsNotMet(&[
374 "device extension `ext_shader_stencil_export`",
375 ]));
376 }
377 }
378 Capability::SubgroupBallotKHR => {
379 if !(device.enabled_extensions().ext_shader_subgroup_ballot) {
380 return Err(ShaderSupportError::RequirementsNotMet(&[
381 "device extension `ext_shader_subgroup_ballot`",
382 ]));
383 }
384 }
385 Capability::SubgroupVoteKHR => {
386 if !(device.enabled_extensions().ext_shader_subgroup_vote) {
387 return Err(ShaderSupportError::RequirementsNotMet(&[
388 "device extension `ext_shader_subgroup_vote`",
389 ]));
390 }
391 }
392 Capability::ImageReadWriteLodAMD => {
393 if !(device.enabled_extensions().amd_shader_image_load_store_lod) {
394 return Err(ShaderSupportError::RequirementsNotMet(&[
395 "device extension `amd_shader_image_load_store_lod`",
396 ]));
397 }
398 }
399 Capability::ImageGatherBiasLodAMD => {
400 if !(device.enabled_extensions().amd_texture_gather_bias_lod) {
401 return Err(ShaderSupportError::RequirementsNotMet(&[
402 "device extension `amd_texture_gather_bias_lod`",
403 ]));
404 }
405 }
406 Capability::FragmentMaskAMD => {
407 if !(device.enabled_extensions().amd_shader_fragment_mask) {
408 return Err(ShaderSupportError::RequirementsNotMet(&[
409 "device extension `amd_shader_fragment_mask`",
410 ]));
411 }
412 }
413 Capability::SampleMaskOverrideCoverageNV => {
414 if !(device.enabled_extensions().nv_sample_mask_override_coverage) {
415 return Err(ShaderSupportError::RequirementsNotMet(&[
416 "device extension `nv_sample_mask_override_coverage`",
417 ]));
418 }
419 }
420 Capability::GeometryShaderPassthroughNV => {
421 if !(device.enabled_extensions().nv_geometry_shader_passthrough) {
422 return Err(ShaderSupportError::RequirementsNotMet(&[
423 "device extension `nv_geometry_shader_passthrough`",
424 ]));
425 }
426 }
427 Capability::ShaderViewportIndex => {
428 if !(device.enabled_features().shader_output_viewport_index) {
429 return Err(ShaderSupportError::RequirementsNotMet(&[
430 "feature `shader_output_viewport_index`",
431 ]));
432 }
433 }
434 Capability::ShaderLayer => {
435 if !(device.enabled_features().shader_output_layer) {
436 return Err(ShaderSupportError::RequirementsNotMet(&[
437 "feature `shader_output_layer`",
438 ]));
439 }
440 }
441 Capability::ShaderViewportIndexLayerEXT => {
442 if !(device.enabled_extensions().ext_shader_viewport_index_layer
443 || device.enabled_extensions().nv_viewport_array2)
444 {
445 return Err(ShaderSupportError::RequirementsNotMet(&[
446 "device extension `ext_shader_viewport_index_layer`",
447 "device extension `nv_viewport_array2`",
448 ]));
449 }
450 }
451 Capability::ShaderViewportMaskNV => {
452 if !(device.enabled_extensions().nv_viewport_array2) {
453 return Err(ShaderSupportError::RequirementsNotMet(&[
454 "device extension `nv_viewport_array2`",
455 ]));
456 }
457 }
458 Capability::PerViewAttributesNV => {
459 if !(device
460 .enabled_extensions()
461 .nvx_multiview_per_view_attributes)
462 {
463 return Err(ShaderSupportError::RequirementsNotMet(&[
464 "device extension `nvx_multiview_per_view_attributes`",
465 ]));
466 }
467 }
468 Capability::StorageBuffer16BitAccess => {
469 if !(device.enabled_features().storage_buffer16_bit_access) {
470 return Err(ShaderSupportError::RequirementsNotMet(&[
471 "feature `storage_buffer16_bit_access`",
472 ]));
473 }
474 }
475 Capability::UniformAndStorageBuffer16BitAccess => {
476 if !(device
477 .enabled_features()
478 .uniform_and_storage_buffer16_bit_access)
479 {
480 return Err(ShaderSupportError::RequirementsNotMet(&[
481 "feature `uniform_and_storage_buffer16_bit_access`",
482 ]));
483 }
484 }
485 Capability::StoragePushConstant16 => {
486 if !(device.enabled_features().storage_push_constant16) {
487 return Err(ShaderSupportError::RequirementsNotMet(&[
488 "feature `storage_push_constant16`",
489 ]));
490 }
491 }
492 Capability::StorageInputOutput16 => {
493 if !(device.enabled_features().storage_input_output16) {
494 return Err(ShaderSupportError::RequirementsNotMet(&[
495 "feature `storage_input_output16`",
496 ]));
497 }
498 }
499 Capability::GroupNonUniform => {
500 if !(device
501 .physical_device()
502 .properties()
503 .subgroup_supported_operations
504 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::BASIC))
505 .unwrap_or(false))
506 {
507 return Err(ShaderSupportError::RequirementsNotMet(&[
508 "property `subgroup_supported_operations.BASIC`",
509 ]));
510 }
511 }
512 Capability::GroupNonUniformVote => {
513 if !(device
514 .physical_device()
515 .properties()
516 .subgroup_supported_operations
517 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::VOTE))
518 .unwrap_or(false))
519 {
520 return Err(ShaderSupportError::RequirementsNotMet(&[
521 "property `subgroup_supported_operations.VOTE`",
522 ]));
523 }
524 }
525 Capability::GroupNonUniformArithmetic => {
526 if !(device
527 .physical_device()
528 .properties()
529 .subgroup_supported_operations
530 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::ARITHMETIC))
531 .unwrap_or(false))
532 {
533 return Err(ShaderSupportError::RequirementsNotMet(&[
534 "property `subgroup_supported_operations.ARITHMETIC`",
535 ]));
536 }
537 }
538 Capability::GroupNonUniformBallot => {
539 if !(device
540 .physical_device()
541 .properties()
542 .subgroup_supported_operations
543 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::BALLOT))
544 .unwrap_or(false))
545 {
546 return Err(ShaderSupportError::RequirementsNotMet(&[
547 "property `subgroup_supported_operations.BALLOT`",
548 ]));
549 }
550 }
551 Capability::GroupNonUniformShuffle => {
552 if !(device
553 .physical_device()
554 .properties()
555 .subgroup_supported_operations
556 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::SHUFFLE))
557 .unwrap_or(false))
558 {
559 return Err(ShaderSupportError::RequirementsNotMet(&[
560 "property `subgroup_supported_operations.SHUFFLE`",
561 ]));
562 }
563 }
564 Capability::GroupNonUniformShuffleRelative => {
565 if !(device
566 .physical_device()
567 .properties()
568 .subgroup_supported_operations
569 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::SHUFFLE_RELATIVE))
570 .unwrap_or(false))
571 {
572 return Err(ShaderSupportError::RequirementsNotMet(&[
573 "property `subgroup_supported_operations.SHUFFLE_RELATIVE`",
574 ]));
575 }
576 }
577 Capability::GroupNonUniformClustered => {
578 if !(device
579 .physical_device()
580 .properties()
581 .subgroup_supported_operations
582 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::CLUSTERED))
583 .unwrap_or(false))
584 {
585 return Err(ShaderSupportError::RequirementsNotMet(&[
586 "property `subgroup_supported_operations.CLUSTERED`",
587 ]));
588 }
589 }
590 Capability::GroupNonUniformQuad => {
591 if !(device
592 .physical_device()
593 .properties()
594 .subgroup_supported_operations
595 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::QUAD))
596 .unwrap_or(false))
597 {
598 return Err(ShaderSupportError::RequirementsNotMet(&[
599 "property `subgroup_supported_operations.QUAD`",
600 ]));
601 }
602 }
603 Capability::GroupNonUniformPartitionedNV => {
604 if !(device
605 .physical_device()
606 .properties()
607 .subgroup_supported_operations
608 .map(|x| x.intersects(crate::device::physical::SubgroupFeatures::PARTITIONED))
609 .unwrap_or(false))
610 {
611 return Err(ShaderSupportError::RequirementsNotMet(&[
612 "property `subgroup_supported_operations.PARTITIONED`",
613 ]));
614 }
615 }
616 Capability::SampleMaskPostDepthCoverage => {
617 if !(device.enabled_extensions().ext_post_depth_coverage) {
618 return Err(ShaderSupportError::RequirementsNotMet(&[
619 "device extension `ext_post_depth_coverage`",
620 ]));
621 }
622 }
623 Capability::ShaderNonUniform => {
624 if !(device.api_version() >= Version::V1_1
625 || device.enabled_extensions().ext_descriptor_indexing)
626 {
627 return Err(ShaderSupportError::RequirementsNotMet(&[
628 "Vulkan API version 1.1",
629 "device extension `ext_descriptor_indexing`",
630 ]));
631 }
632 }
633 Capability::RuntimeDescriptorArray => {
634 if !(device.enabled_features().runtime_descriptor_array) {
635 return Err(ShaderSupportError::RequirementsNotMet(&[
636 "feature `runtime_descriptor_array`",
637 ]));
638 }
639 }
640 Capability::InputAttachmentArrayDynamicIndexing => {
641 if !(device
642 .enabled_features()
643 .shader_input_attachment_array_dynamic_indexing)
644 {
645 return Err(ShaderSupportError::RequirementsNotMet(&[
646 "feature `shader_input_attachment_array_dynamic_indexing`",
647 ]));
648 }
649 }
650 Capability::UniformTexelBufferArrayDynamicIndexing => {
651 if !(device
652 .enabled_features()
653 .shader_uniform_texel_buffer_array_dynamic_indexing)
654 {
655 return Err(ShaderSupportError::RequirementsNotMet(&[
656 "feature `shader_uniform_texel_buffer_array_dynamic_indexing`",
657 ]));
658 }
659 }
660 Capability::StorageTexelBufferArrayDynamicIndexing => {
661 if !(device
662 .enabled_features()
663 .shader_storage_texel_buffer_array_dynamic_indexing)
664 {
665 return Err(ShaderSupportError::RequirementsNotMet(&[
666 "feature `shader_storage_texel_buffer_array_dynamic_indexing`",
667 ]));
668 }
669 }
670 Capability::UniformBufferArrayNonUniformIndexing => {
671 if !(device
672 .enabled_features()
673 .shader_uniform_buffer_array_non_uniform_indexing)
674 {
675 return Err(ShaderSupportError::RequirementsNotMet(&[
676 "feature `shader_uniform_buffer_array_non_uniform_indexing`",
677 ]));
678 }
679 }
680 Capability::SampledImageArrayNonUniformIndexing => {
681 if !(device
682 .enabled_features()
683 .shader_sampled_image_array_non_uniform_indexing)
684 {
685 return Err(ShaderSupportError::RequirementsNotMet(&[
686 "feature `shader_sampled_image_array_non_uniform_indexing`",
687 ]));
688 }
689 }
690 Capability::StorageBufferArrayNonUniformIndexing => {
691 if !(device
692 .enabled_features()
693 .shader_storage_buffer_array_non_uniform_indexing)
694 {
695 return Err(ShaderSupportError::RequirementsNotMet(&[
696 "feature `shader_storage_buffer_array_non_uniform_indexing`",
697 ]));
698 }
699 }
700 Capability::StorageImageArrayNonUniformIndexing => {
701 if !(device
702 .enabled_features()
703 .shader_storage_image_array_non_uniform_indexing)
704 {
705 return Err(ShaderSupportError::RequirementsNotMet(&[
706 "feature `shader_storage_image_array_non_uniform_indexing`",
707 ]));
708 }
709 }
710 Capability::InputAttachmentArrayNonUniformIndexing => {
711 if !(device
712 .enabled_features()
713 .shader_input_attachment_array_non_uniform_indexing)
714 {
715 return Err(ShaderSupportError::RequirementsNotMet(&[
716 "feature `shader_input_attachment_array_non_uniform_indexing`",
717 ]));
718 }
719 }
720 Capability::UniformTexelBufferArrayNonUniformIndexing => {
721 if !(device
722 .enabled_features()
723 .shader_uniform_texel_buffer_array_non_uniform_indexing)
724 {
725 return Err(ShaderSupportError::RequirementsNotMet(&[
726 "feature `shader_uniform_texel_buffer_array_non_uniform_indexing`",
727 ]));
728 }
729 }
730 Capability::StorageTexelBufferArrayNonUniformIndexing => {
731 if !(device
732 .enabled_features()
733 .shader_storage_texel_buffer_array_non_uniform_indexing)
734 {
735 return Err(ShaderSupportError::RequirementsNotMet(&[
736 "feature `shader_storage_texel_buffer_array_non_uniform_indexing`",
737 ]));
738 }
739 }
740 Capability::FragmentFullyCoveredEXT => {
741 if !(device.enabled_extensions().ext_conservative_rasterization) {
742 return Err(ShaderSupportError::RequirementsNotMet(&[
743 "device extension `ext_conservative_rasterization`",
744 ]));
745 }
746 }
747 Capability::Float16 => {
748 if !(device.enabled_features().shader_float16
749 || device.enabled_extensions().amd_gpu_shader_half_float)
750 {
751 return Err(ShaderSupportError::RequirementsNotMet(&[
752 "feature `shader_float16`",
753 "device extension `amd_gpu_shader_half_float`",
754 ]));
755 }
756 }
757 Capability::Int8 => {
758 if !(device.enabled_features().shader_int8) {
759 return Err(ShaderSupportError::RequirementsNotMet(&[
760 "feature `shader_int8`",
761 ]));
762 }
763 }
764 Capability::StorageBuffer8BitAccess => {
765 if !(device.enabled_features().storage_buffer8_bit_access) {
766 return Err(ShaderSupportError::RequirementsNotMet(&[
767 "feature `storage_buffer8_bit_access`",
768 ]));
769 }
770 }
771 Capability::UniformAndStorageBuffer8BitAccess => {
772 if !(device
773 .enabled_features()
774 .uniform_and_storage_buffer8_bit_access)
775 {
776 return Err(ShaderSupportError::RequirementsNotMet(&[
777 "feature `uniform_and_storage_buffer8_bit_access`",
778 ]));
779 }
780 }
781 Capability::StoragePushConstant8 => {
782 if !(device.enabled_features().storage_push_constant8) {
783 return Err(ShaderSupportError::RequirementsNotMet(&[
784 "feature `storage_push_constant8`",
785 ]));
786 }
787 }
788 Capability::VulkanMemoryModel => {
789 if !(device.enabled_features().vulkan_memory_model) {
790 return Err(ShaderSupportError::RequirementsNotMet(&[
791 "feature `vulkan_memory_model`",
792 ]));
793 }
794 }
795 Capability::VulkanMemoryModelDeviceScope => {
796 if !(device.enabled_features().vulkan_memory_model_device_scope) {
797 return Err(ShaderSupportError::RequirementsNotMet(&[
798 "feature `vulkan_memory_model_device_scope`",
799 ]));
800 }
801 }
802 Capability::DenormPreserve => {
803 if !(device
804 .physical_device()
805 .properties()
806 .shader_denorm_preserve_float16
807 .unwrap_or(false)
808 || device
809 .physical_device()
810 .properties()
811 .shader_denorm_preserve_float32
812 .unwrap_or(false)
813 || device
814 .physical_device()
815 .properties()
816 .shader_denorm_preserve_float64
817 .unwrap_or(false))
818 {
819 return Err(ShaderSupportError::RequirementsNotMet(&[
820 "property `shader_denorm_preserve_float16`",
821 "property `shader_denorm_preserve_float32`",
822 "property `shader_denorm_preserve_float64`",
823 ]));
824 }
825 }
826 Capability::DenormFlushToZero => {
827 if !(device
828 .physical_device()
829 .properties()
830 .shader_denorm_flush_to_zero_float16
831 .unwrap_or(false)
832 || device
833 .physical_device()
834 .properties()
835 .shader_denorm_flush_to_zero_float32
836 .unwrap_or(false)
837 || device
838 .physical_device()
839 .properties()
840 .shader_denorm_flush_to_zero_float64
841 .unwrap_or(false))
842 {
843 return Err(ShaderSupportError::RequirementsNotMet(&[
844 "property `shader_denorm_flush_to_zero_float16`",
845 "property `shader_denorm_flush_to_zero_float32`",
846 "property `shader_denorm_flush_to_zero_float64`",
847 ]));
848 }
849 }
850 Capability::SignedZeroInfNanPreserve => {
851 if !(device
852 .physical_device()
853 .properties()
854 .shader_signed_zero_inf_nan_preserve_float16
855 .unwrap_or(false)
856 || device
857 .physical_device()
858 .properties()
859 .shader_signed_zero_inf_nan_preserve_float32
860 .unwrap_or(false)
861 || device
862 .physical_device()
863 .properties()
864 .shader_signed_zero_inf_nan_preserve_float64
865 .unwrap_or(false))
866 {
867 return Err(ShaderSupportError::RequirementsNotMet(&[
868 "property `shader_signed_zero_inf_nan_preserve_float16`",
869 "property `shader_signed_zero_inf_nan_preserve_float32`",
870 "property `shader_signed_zero_inf_nan_preserve_float64`",
871 ]));
872 }
873 }
874 Capability::RoundingModeRTE => {
875 if !(device
876 .physical_device()
877 .properties()
878 .shader_rounding_mode_rte_float16
879 .unwrap_or(false)
880 || device
881 .physical_device()
882 .properties()
883 .shader_rounding_mode_rte_float32
884 .unwrap_or(false)
885 || device
886 .physical_device()
887 .properties()
888 .shader_rounding_mode_rte_float64
889 .unwrap_or(false))
890 {
891 return Err(ShaderSupportError::RequirementsNotMet(&[
892 "property `shader_rounding_mode_rte_float16`",
893 "property `shader_rounding_mode_rte_float32`",
894 "property `shader_rounding_mode_rte_float64`",
895 ]));
896 }
897 }
898 Capability::RoundingModeRTZ => {
899 if !(device
900 .physical_device()
901 .properties()
902 .shader_rounding_mode_rtz_float16
903 .unwrap_or(false)
904 || device
905 .physical_device()
906 .properties()
907 .shader_rounding_mode_rtz_float32
908 .unwrap_or(false)
909 || device
910 .physical_device()
911 .properties()
912 .shader_rounding_mode_rtz_float64
913 .unwrap_or(false))
914 {
915 return Err(ShaderSupportError::RequirementsNotMet(&[
916 "property `shader_rounding_mode_rtz_float16`",
917 "property `shader_rounding_mode_rtz_float32`",
918 "property `shader_rounding_mode_rtz_float64`",
919 ]));
920 }
921 }
922 Capability::ComputeDerivativeGroupQuadsNV => {
923 if !(device.enabled_features().compute_derivative_group_quads) {
924 return Err(ShaderSupportError::RequirementsNotMet(&[
925 "feature `compute_derivative_group_quads`",
926 ]));
927 }
928 }
929 Capability::ComputeDerivativeGroupLinearNV => {
930 if !(device.enabled_features().compute_derivative_group_linear) {
931 return Err(ShaderSupportError::RequirementsNotMet(&[
932 "feature `compute_derivative_group_linear`",
933 ]));
934 }
935 }
936 Capability::FragmentBarycentricKHR => {
937 if !(device.enabled_features().fragment_shader_barycentric
938 || device.enabled_features().fragment_shader_barycentric)
939 {
940 return Err(ShaderSupportError::RequirementsNotMet(&[
941 "feature `fragment_shader_barycentric`",
942 "feature `fragment_shader_barycentric`",
943 ]));
944 }
945 }
946 Capability::ImageFootprintNV => {
947 if !(device.enabled_features().image_footprint) {
948 return Err(ShaderSupportError::RequirementsNotMet(&[
949 "feature `image_footprint`",
950 ]));
951 }
952 }
953 Capability::FragmentDensityEXT => {
954 if !(device.enabled_features().shading_rate_image
955 || device.enabled_features().fragment_density_map)
956 {
957 return Err(ShaderSupportError::RequirementsNotMet(&[
958 "feature `shading_rate_image`",
959 "feature `fragment_density_map`",
960 ]));
961 }
962 }
963 Capability::MeshShadingNV => {
964 if !(device.enabled_extensions().nv_mesh_shader) {
965 return Err(ShaderSupportError::RequirementsNotMet(&[
966 "device extension `nv_mesh_shader`",
967 ]));
968 }
969 }
970 Capability::RayTracingKHR => {
971 if !(device.enabled_features().ray_tracing_pipeline) {
972 return Err(ShaderSupportError::RequirementsNotMet(&[
973 "feature `ray_tracing_pipeline`",
974 ]));
975 }
976 }
977 Capability::RayQueryKHR => {
978 if !(device.enabled_features().ray_query) {
979 return Err(ShaderSupportError::RequirementsNotMet(&[
980 "feature `ray_query`",
981 ]));
982 }
983 }
984 Capability::RayTraversalPrimitiveCullingKHR => {
985 if !(device.enabled_features().ray_traversal_primitive_culling
986 || device.enabled_features().ray_query)
987 {
988 return Err(ShaderSupportError::RequirementsNotMet(&[
989 "feature `ray_traversal_primitive_culling`",
990 "feature `ray_query`",
991 ]));
992 }
993 }
994 Capability::RayTracingNV => {
995 if !(device.enabled_extensions().nv_ray_tracing) {
996 return Err(ShaderSupportError::RequirementsNotMet(&[
997 "device extension `nv_ray_tracing`",
998 ]));
999 }
1000 }
1001 Capability::RayTracingMotionBlurNV => {
1002 if !(device.enabled_features().ray_tracing_motion_blur) {
1003 return Err(ShaderSupportError::RequirementsNotMet(&[
1004 "feature `ray_tracing_motion_blur`",
1005 ]));
1006 }
1007 }
1008 Capability::TransformFeedback => {
1009 if !(device.enabled_features().transform_feedback) {
1010 return Err(ShaderSupportError::RequirementsNotMet(&[
1011 "feature `transform_feedback`",
1012 ]));
1013 }
1014 }
1015 Capability::GeometryStreams => {
1016 if !(device.enabled_features().geometry_streams) {
1017 return Err(ShaderSupportError::RequirementsNotMet(&[
1018 "feature `geometry_streams`",
1019 ]));
1020 }
1021 }
1022 Capability::PhysicalStorageBufferAddresses => {
1023 if !(device.enabled_features().buffer_device_address) {
1024 return Err(ShaderSupportError::RequirementsNotMet(&[
1025 "feature `buffer_device_address`",
1026 ]));
1027 }
1028 }
1029 Capability::CooperativeMatrixNV => {
1030 if !(device.enabled_features().cooperative_matrix) {
1031 return Err(ShaderSupportError::RequirementsNotMet(&[
1032 "feature `cooperative_matrix`",
1033 ]));
1034 }
1035 }
1036 Capability::IntegerFunctions2INTEL => {
1037 if !(device.enabled_features().shader_integer_functions2) {
1038 return Err(ShaderSupportError::RequirementsNotMet(&[
1039 "feature `shader_integer_functions2`",
1040 ]));
1041 }
1042 }
1043 Capability::ShaderSMBuiltinsNV => {
1044 if !(device.enabled_features().shader_sm_builtins) {
1045 return Err(ShaderSupportError::RequirementsNotMet(&[
1046 "feature `shader_sm_builtins`",
1047 ]));
1048 }
1049 }
1050 Capability::FragmentShaderSampleInterlockEXT => {
1051 if !(device.enabled_features().fragment_shader_sample_interlock) {
1052 return Err(ShaderSupportError::RequirementsNotMet(&[
1053 "feature `fragment_shader_sample_interlock`",
1054 ]));
1055 }
1056 }
1057 Capability::FragmentShaderPixelInterlockEXT => {
1058 if !(device.enabled_features().fragment_shader_pixel_interlock) {
1059 return Err(ShaderSupportError::RequirementsNotMet(&[
1060 "feature `fragment_shader_pixel_interlock`",
1061 ]));
1062 }
1063 }
1064 Capability::FragmentShaderShadingRateInterlockEXT => {
1065 if !(device
1066 .enabled_features()
1067 .fragment_shader_shading_rate_interlock
1068 || device.enabled_features().shading_rate_image)
1069 {
1070 return Err(ShaderSupportError::RequirementsNotMet(&[
1071 "feature `fragment_shader_shading_rate_interlock`",
1072 "feature `shading_rate_image`",
1073 ]));
1074 }
1075 }
1076 Capability::DemoteToHelperInvocation => {
1077 if !(device.enabled_features().shader_demote_to_helper_invocation) {
1078 return Err(ShaderSupportError::RequirementsNotMet(&[
1079 "feature `shader_demote_to_helper_invocation`",
1080 ]));
1081 }
1082 }
1083 Capability::FragmentShadingRateKHR => {
1084 if !(device.enabled_features().pipeline_fragment_shading_rate
1085 || device.enabled_features().primitive_fragment_shading_rate
1086 || device.enabled_features().attachment_fragment_shading_rate)
1087 {
1088 return Err(ShaderSupportError::RequirementsNotMet(&[
1089 "feature `pipeline_fragment_shading_rate`",
1090 "feature `primitive_fragment_shading_rate`",
1091 "feature `attachment_fragment_shading_rate`",
1092 ]));
1093 }
1094 }
1095 Capability::WorkgroupMemoryExplicitLayoutKHR => {
1096 if !(device.enabled_features().workgroup_memory_explicit_layout) {
1097 return Err(ShaderSupportError::RequirementsNotMet(&[
1098 "feature `workgroup_memory_explicit_layout`",
1099 ]));
1100 }
1101 }
1102 Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR => {
1103 if !(device
1104 .enabled_features()
1105 .workgroup_memory_explicit_layout8_bit_access)
1106 {
1107 return Err(ShaderSupportError::RequirementsNotMet(&[
1108 "feature `workgroup_memory_explicit_layout8_bit_access`",
1109 ]));
1110 }
1111 }
1112 Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR => {
1113 if !(device
1114 .enabled_features()
1115 .workgroup_memory_explicit_layout16_bit_access)
1116 {
1117 return Err(ShaderSupportError::RequirementsNotMet(&[
1118 "feature `workgroup_memory_explicit_layout16_bit_access`",
1119 ]));
1120 }
1121 }
1122 Capability::DotProductInputAll => {
1123 if !(device.enabled_features().shader_integer_dot_product) {
1124 return Err(ShaderSupportError::RequirementsNotMet(&[
1125 "feature `shader_integer_dot_product`",
1126 ]));
1127 }
1128 }
1129 Capability::DotProductInput4x8Bit => {
1130 if !(device.enabled_features().shader_integer_dot_product) {
1131 return Err(ShaderSupportError::RequirementsNotMet(&[
1132 "feature `shader_integer_dot_product`",
1133 ]));
1134 }
1135 }
1136 Capability::DotProductInput4x8BitPacked => {
1137 if !(device.enabled_features().shader_integer_dot_product) {
1138 return Err(ShaderSupportError::RequirementsNotMet(&[
1139 "feature `shader_integer_dot_product`",
1140 ]));
1141 }
1142 }
1143 Capability::DotProduct => {
1144 if !(device.enabled_features().shader_integer_dot_product) {
1145 return Err(ShaderSupportError::RequirementsNotMet(&[
1146 "feature `shader_integer_dot_product`",
1147 ]));
1148 }
1149 }
1150 _ => return Err(ShaderSupportError::NotSupportedByVulkan),
1151 }
1152 Ok(())
1153 }
check_spirv_extension(device: &Device, extension: &str) -> Result<(), ShaderSupportError>1154 fn check_spirv_extension(device: &Device, extension: &str) -> Result<(), ShaderSupportError> {
1155 match extension {
1156 "SPV_KHR_variable_pointers" => {
1157 if !(device.api_version() >= Version::V1_1
1158 || device.enabled_extensions().khr_variable_pointers)
1159 {
1160 return Err(ShaderSupportError::RequirementsNotMet(&[
1161 "Vulkan API version 1.1",
1162 "device extension `khr_variable_pointers`",
1163 ]));
1164 }
1165 }
1166 "SPV_AMD_shader_explicit_vertex_parameter" => {
1167 if !(device
1168 .enabled_extensions()
1169 .amd_shader_explicit_vertex_parameter)
1170 {
1171 return Err(ShaderSupportError::RequirementsNotMet(&[
1172 "device extension `amd_shader_explicit_vertex_parameter`",
1173 ]));
1174 }
1175 }
1176 "SPV_AMD_gcn_shader" => {
1177 if !(device.enabled_extensions().amd_gcn_shader) {
1178 return Err(ShaderSupportError::RequirementsNotMet(&[
1179 "device extension `amd_gcn_shader`",
1180 ]));
1181 }
1182 }
1183 "SPV_AMD_gpu_shader_half_float" => {
1184 if !(device.enabled_extensions().amd_gpu_shader_half_float) {
1185 return Err(ShaderSupportError::RequirementsNotMet(&[
1186 "device extension `amd_gpu_shader_half_float`",
1187 ]));
1188 }
1189 }
1190 "SPV_AMD_gpu_shader_int16" => {
1191 if !(device.enabled_extensions().amd_gpu_shader_int16) {
1192 return Err(ShaderSupportError::RequirementsNotMet(&[
1193 "device extension `amd_gpu_shader_int16`",
1194 ]));
1195 }
1196 }
1197 "SPV_AMD_shader_ballot" => {
1198 if !(device.enabled_extensions().amd_shader_ballot) {
1199 return Err(ShaderSupportError::RequirementsNotMet(&[
1200 "device extension `amd_shader_ballot`",
1201 ]));
1202 }
1203 }
1204 "SPV_AMD_shader_fragment_mask" => {
1205 if !(device.enabled_extensions().amd_shader_fragment_mask) {
1206 return Err(ShaderSupportError::RequirementsNotMet(&[
1207 "device extension `amd_shader_fragment_mask`",
1208 ]));
1209 }
1210 }
1211 "SPV_AMD_shader_image_load_store_lod" => {
1212 if !(device.enabled_extensions().amd_shader_image_load_store_lod) {
1213 return Err(ShaderSupportError::RequirementsNotMet(&[
1214 "device extension `amd_shader_image_load_store_lod`",
1215 ]));
1216 }
1217 }
1218 "SPV_AMD_shader_trinary_minmax" => {
1219 if !(device.enabled_extensions().amd_shader_trinary_minmax) {
1220 return Err(ShaderSupportError::RequirementsNotMet(&[
1221 "device extension `amd_shader_trinary_minmax`",
1222 ]));
1223 }
1224 }
1225 "SPV_AMD_texture_gather_bias_lod" => {
1226 if !(device.enabled_extensions().amd_texture_gather_bias_lod) {
1227 return Err(ShaderSupportError::RequirementsNotMet(&[
1228 "device extension `amd_texture_gather_bias_lod`",
1229 ]));
1230 }
1231 }
1232 "SPV_AMD_shader_early_and_late_fragment_tests" => {
1233 if !(device
1234 .enabled_extensions()
1235 .amd_shader_early_and_late_fragment_tests)
1236 {
1237 return Err(ShaderSupportError::RequirementsNotMet(&[
1238 "device extension `amd_shader_early_and_late_fragment_tests`",
1239 ]));
1240 }
1241 }
1242 "SPV_KHR_shader_draw_parameters" => {
1243 if !(device.api_version() >= Version::V1_1
1244 || device.enabled_extensions().khr_shader_draw_parameters)
1245 {
1246 return Err(ShaderSupportError::RequirementsNotMet(&[
1247 "Vulkan API version 1.1",
1248 "device extension `khr_shader_draw_parameters`",
1249 ]));
1250 }
1251 }
1252 "SPV_KHR_8bit_storage" => {
1253 if !(device.api_version() >= Version::V1_1
1254 || device.enabled_extensions().khr_8bit_storage)
1255 {
1256 return Err(ShaderSupportError::RequirementsNotMet(&[
1257 "Vulkan API version 1.1",
1258 "device extension `khr_8bit_storage`",
1259 ]));
1260 }
1261 }
1262 "SPV_KHR_16bit_storage" => {
1263 if !(device.api_version() >= Version::V1_1
1264 || device.enabled_extensions().khr_16bit_storage)
1265 {
1266 return Err(ShaderSupportError::RequirementsNotMet(&[
1267 "Vulkan API version 1.1",
1268 "device extension `khr_16bit_storage`",
1269 ]));
1270 }
1271 }
1272 "SPV_KHR_shader_clock" => {
1273 if !(device.enabled_extensions().khr_shader_clock) {
1274 return Err(ShaderSupportError::RequirementsNotMet(&[
1275 "device extension `khr_shader_clock`",
1276 ]));
1277 }
1278 }
1279 "SPV_KHR_float_controls" => {
1280 if !(device.api_version() >= Version::V1_1
1281 || device.enabled_extensions().khr_shader_float_controls)
1282 {
1283 return Err(ShaderSupportError::RequirementsNotMet(&[
1284 "Vulkan API version 1.1",
1285 "device extension `khr_shader_float_controls`",
1286 ]));
1287 }
1288 }
1289 "SPV_KHR_storage_buffer_storage_class" => {
1290 if !(device.api_version() >= Version::V1_1
1291 || device.enabled_extensions().khr_storage_buffer_storage_class)
1292 {
1293 return Err(ShaderSupportError::RequirementsNotMet(&[
1294 "Vulkan API version 1.1",
1295 "device extension `khr_storage_buffer_storage_class`",
1296 ]));
1297 }
1298 }
1299 "SPV_KHR_post_depth_coverage" => {
1300 if !(device.enabled_extensions().ext_post_depth_coverage) {
1301 return Err(ShaderSupportError::RequirementsNotMet(&[
1302 "device extension `ext_post_depth_coverage`",
1303 ]));
1304 }
1305 }
1306 "SPV_EXT_shader_stencil_export" => {
1307 if !(device.enabled_extensions().ext_shader_stencil_export) {
1308 return Err(ShaderSupportError::RequirementsNotMet(&[
1309 "device extension `ext_shader_stencil_export`",
1310 ]));
1311 }
1312 }
1313 "SPV_KHR_shader_ballot" => {
1314 if !(device.enabled_extensions().ext_shader_subgroup_ballot) {
1315 return Err(ShaderSupportError::RequirementsNotMet(&[
1316 "device extension `ext_shader_subgroup_ballot`",
1317 ]));
1318 }
1319 }
1320 "SPV_KHR_subgroup_vote" => {
1321 if !(device.enabled_extensions().ext_shader_subgroup_vote) {
1322 return Err(ShaderSupportError::RequirementsNotMet(&[
1323 "device extension `ext_shader_subgroup_vote`",
1324 ]));
1325 }
1326 }
1327 "SPV_NV_sample_mask_override_coverage" => {
1328 if !(device.enabled_extensions().nv_sample_mask_override_coverage) {
1329 return Err(ShaderSupportError::RequirementsNotMet(&[
1330 "device extension `nv_sample_mask_override_coverage`",
1331 ]));
1332 }
1333 }
1334 "SPV_NV_geometry_shader_passthrough" => {
1335 if !(device.enabled_extensions().nv_geometry_shader_passthrough) {
1336 return Err(ShaderSupportError::RequirementsNotMet(&[
1337 "device extension `nv_geometry_shader_passthrough`",
1338 ]));
1339 }
1340 }
1341 "SPV_NV_mesh_shader" => {
1342 if !(device.enabled_extensions().nv_mesh_shader) {
1343 return Err(ShaderSupportError::RequirementsNotMet(&[
1344 "device extension `nv_mesh_shader`",
1345 ]));
1346 }
1347 }
1348 "SPV_NV_viewport_array2" => {
1349 if !(device.enabled_extensions().nv_viewport_array2) {
1350 return Err(ShaderSupportError::RequirementsNotMet(&[
1351 "device extension `nv_viewport_array2`",
1352 ]));
1353 }
1354 }
1355 "SPV_NV_shader_subgroup_partitioned" => {
1356 if !(device.enabled_extensions().nv_shader_subgroup_partitioned) {
1357 return Err(ShaderSupportError::RequirementsNotMet(&[
1358 "device extension `nv_shader_subgroup_partitioned`",
1359 ]));
1360 }
1361 }
1362 "SPV_NV_shader_invocation_reorder" => {
1363 if !(device
1364 .enabled_extensions()
1365 .nv_ray_tracing_invocation_reorder)
1366 {
1367 return Err(ShaderSupportError::RequirementsNotMet(&[
1368 "device extension `nv_ray_tracing_invocation_reorder`",
1369 ]));
1370 }
1371 }
1372 "SPV_EXT_shader_viewport_index_layer" => {
1373 if !(device.api_version() >= Version::V1_1
1374 || device.enabled_extensions().ext_shader_viewport_index_layer)
1375 {
1376 return Err(ShaderSupportError::RequirementsNotMet(&[
1377 "Vulkan API version 1.1",
1378 "device extension `ext_shader_viewport_index_layer`",
1379 ]));
1380 }
1381 }
1382 "SPV_NVX_multiview_per_view_attributes" => {
1383 if !(device
1384 .enabled_extensions()
1385 .nvx_multiview_per_view_attributes)
1386 {
1387 return Err(ShaderSupportError::RequirementsNotMet(&[
1388 "device extension `nvx_multiview_per_view_attributes`",
1389 ]));
1390 }
1391 }
1392 "SPV_EXT_descriptor_indexing" => {
1393 if !(device.api_version() >= Version::V1_1
1394 || device.enabled_extensions().ext_descriptor_indexing)
1395 {
1396 return Err(ShaderSupportError::RequirementsNotMet(&[
1397 "Vulkan API version 1.1",
1398 "device extension `ext_descriptor_indexing`",
1399 ]));
1400 }
1401 }
1402 "SPV_KHR_vulkan_memory_model" => {
1403 if !(device.api_version() >= Version::V1_1
1404 || device.enabled_extensions().khr_vulkan_memory_model)
1405 {
1406 return Err(ShaderSupportError::RequirementsNotMet(&[
1407 "Vulkan API version 1.1",
1408 "device extension `khr_vulkan_memory_model`",
1409 ]));
1410 }
1411 }
1412 "SPV_NV_compute_shader_derivatives" => {
1413 if !(device.enabled_extensions().nv_compute_shader_derivatives) {
1414 return Err(ShaderSupportError::RequirementsNotMet(&[
1415 "device extension `nv_compute_shader_derivatives`",
1416 ]));
1417 }
1418 }
1419 "SPV_NV_fragment_shader_barycentric" => {
1420 if !(device.enabled_extensions().nv_fragment_shader_barycentric) {
1421 return Err(ShaderSupportError::RequirementsNotMet(&[
1422 "device extension `nv_fragment_shader_barycentric`",
1423 ]));
1424 }
1425 }
1426 "SPV_NV_shader_image_footprint" => {
1427 if !(device.enabled_extensions().nv_shader_image_footprint) {
1428 return Err(ShaderSupportError::RequirementsNotMet(&[
1429 "device extension `nv_shader_image_footprint`",
1430 ]));
1431 }
1432 }
1433 "SPV_NV_shading_rate" => {
1434 if !(device.enabled_extensions().nv_shading_rate_image) {
1435 return Err(ShaderSupportError::RequirementsNotMet(&[
1436 "device extension `nv_shading_rate_image`",
1437 ]));
1438 }
1439 }
1440 "SPV_NV_ray_tracing" => {
1441 if !(device.enabled_extensions().nv_ray_tracing) {
1442 return Err(ShaderSupportError::RequirementsNotMet(&[
1443 "device extension `nv_ray_tracing`",
1444 ]));
1445 }
1446 }
1447 "SPV_KHR_ray_tracing" => {
1448 if !(device.enabled_extensions().khr_ray_tracing_pipeline) {
1449 return Err(ShaderSupportError::RequirementsNotMet(&[
1450 "device extension `khr_ray_tracing_pipeline`",
1451 ]));
1452 }
1453 }
1454 "SPV_KHR_ray_query" => {
1455 if !(device.enabled_extensions().khr_ray_query) {
1456 return Err(ShaderSupportError::RequirementsNotMet(&[
1457 "device extension `khr_ray_query`",
1458 ]));
1459 }
1460 }
1461 "SPV_KHR_ray_cull_mask" => {
1462 if !(device.enabled_extensions().khr_ray_tracing_maintenance1) {
1463 return Err(ShaderSupportError::RequirementsNotMet(&[
1464 "device extension `khr_ray_tracing_maintenance1`",
1465 ]));
1466 }
1467 }
1468 "SPV_GOOGLE_hlsl_functionality1" => {
1469 if !(device.enabled_extensions().google_hlsl_functionality1) {
1470 return Err(ShaderSupportError::RequirementsNotMet(&[
1471 "device extension `google_hlsl_functionality1`",
1472 ]));
1473 }
1474 }
1475 "SPV_GOOGLE_user_type" => {
1476 if !(device.enabled_extensions().google_user_type) {
1477 return Err(ShaderSupportError::RequirementsNotMet(&[
1478 "device extension `google_user_type`",
1479 ]));
1480 }
1481 }
1482 "SPV_GOOGLE_decorate_string" => {
1483 if !(device.enabled_extensions().google_decorate_string) {
1484 return Err(ShaderSupportError::RequirementsNotMet(&[
1485 "device extension `google_decorate_string`",
1486 ]));
1487 }
1488 }
1489 "SPV_EXT_fragment_invocation_density" => {
1490 if !(device.enabled_extensions().ext_fragment_density_map) {
1491 return Err(ShaderSupportError::RequirementsNotMet(&[
1492 "device extension `ext_fragment_density_map`",
1493 ]));
1494 }
1495 }
1496 "SPV_KHR_physical_storage_buffer" => {
1497 if !(device.api_version() >= Version::V1_1
1498 || device.enabled_extensions().khr_buffer_device_address)
1499 {
1500 return Err(ShaderSupportError::RequirementsNotMet(&[
1501 "Vulkan API version 1.1",
1502 "device extension `khr_buffer_device_address`",
1503 ]));
1504 }
1505 }
1506 "SPV_EXT_physical_storage_buffer" => {
1507 if !(device.enabled_extensions().ext_buffer_device_address) {
1508 return Err(ShaderSupportError::RequirementsNotMet(&[
1509 "device extension `ext_buffer_device_address`",
1510 ]));
1511 }
1512 }
1513 "SPV_NV_cooperative_matrix" => {
1514 if !(device.enabled_extensions().nv_cooperative_matrix) {
1515 return Err(ShaderSupportError::RequirementsNotMet(&[
1516 "device extension `nv_cooperative_matrix`",
1517 ]));
1518 }
1519 }
1520 "SPV_NV_shader_sm_builtins" => {
1521 if !(device.enabled_extensions().nv_shader_sm_builtins) {
1522 return Err(ShaderSupportError::RequirementsNotMet(&[
1523 "device extension `nv_shader_sm_builtins`",
1524 ]));
1525 }
1526 }
1527 "SPV_EXT_fragment_shader_interlock" => {
1528 if !(device.enabled_extensions().ext_fragment_shader_interlock) {
1529 return Err(ShaderSupportError::RequirementsNotMet(&[
1530 "device extension `ext_fragment_shader_interlock`",
1531 ]));
1532 }
1533 }
1534 "SPV_EXT_demote_to_helper_invocation" => {
1535 if !(device.api_version() >= Version::V1_1
1536 || device
1537 .enabled_extensions()
1538 .ext_shader_demote_to_helper_invocation)
1539 {
1540 return Err(ShaderSupportError::RequirementsNotMet(&[
1541 "Vulkan API version 1.1",
1542 "device extension `ext_shader_demote_to_helper_invocation`",
1543 ]));
1544 }
1545 }
1546 "SPV_KHR_fragment_shading_rate" => {
1547 if !(device.enabled_extensions().khr_fragment_shading_rate) {
1548 return Err(ShaderSupportError::RequirementsNotMet(&[
1549 "device extension `khr_fragment_shading_rate`",
1550 ]));
1551 }
1552 }
1553 "SPV_KHR_non_semantic_info" => {
1554 if !(device.api_version() >= Version::V1_1
1555 || device.enabled_extensions().khr_shader_non_semantic_info)
1556 {
1557 return Err(ShaderSupportError::RequirementsNotMet(&[
1558 "Vulkan API version 1.1",
1559 "device extension `khr_shader_non_semantic_info`",
1560 ]));
1561 }
1562 }
1563 "SPV_EXT_shader_image_int64" => {
1564 if !(device.enabled_extensions().ext_shader_image_atomic_int64) {
1565 return Err(ShaderSupportError::RequirementsNotMet(&[
1566 "device extension `ext_shader_image_atomic_int64`",
1567 ]));
1568 }
1569 }
1570 "SPV_KHR_terminate_invocation" => {
1571 if !(device.api_version() >= Version::V1_1
1572 || device.enabled_extensions().khr_shader_terminate_invocation)
1573 {
1574 return Err(ShaderSupportError::RequirementsNotMet(&[
1575 "Vulkan API version 1.1",
1576 "device extension `khr_shader_terminate_invocation`",
1577 ]));
1578 }
1579 }
1580 "SPV_KHR_multiview" => {
1581 if !(device.api_version() >= Version::V1_1 || device.enabled_extensions().khr_multiview)
1582 {
1583 return Err(ShaderSupportError::RequirementsNotMet(&[
1584 "Vulkan API version 1.1",
1585 "device extension `khr_multiview`",
1586 ]));
1587 }
1588 }
1589 "SPV_KHR_workgroup_memory_explicit_layout" => {
1590 if !(device
1591 .enabled_extensions()
1592 .khr_workgroup_memory_explicit_layout)
1593 {
1594 return Err(ShaderSupportError::RequirementsNotMet(&[
1595 "device extension `khr_workgroup_memory_explicit_layout`",
1596 ]));
1597 }
1598 }
1599 "SPV_EXT_shader_atomic_float_add" => {
1600 if !(device.enabled_extensions().ext_shader_atomic_float) {
1601 return Err(ShaderSupportError::RequirementsNotMet(&[
1602 "device extension `ext_shader_atomic_float`",
1603 ]));
1604 }
1605 }
1606 "SPV_KHR_fragment_shader_barycentric" => {
1607 if !(device.enabled_extensions().khr_fragment_shader_barycentric) {
1608 return Err(ShaderSupportError::RequirementsNotMet(&[
1609 "device extension `khr_fragment_shader_barycentric`",
1610 ]));
1611 }
1612 }
1613 "SPV_KHR_subgroup_uniform_control_flow" => {
1614 if !(device.api_version() >= Version::V1_1
1615 || device
1616 .enabled_extensions()
1617 .khr_shader_subgroup_uniform_control_flow)
1618 {
1619 return Err(ShaderSupportError::RequirementsNotMet(&[
1620 "Vulkan API version 1.1",
1621 "device extension `khr_shader_subgroup_uniform_control_flow`",
1622 ]));
1623 }
1624 }
1625 "SPV_EXT_shader_atomic_float_min_max" => {
1626 if !(device.enabled_extensions().ext_shader_atomic_float2) {
1627 return Err(ShaderSupportError::RequirementsNotMet(&[
1628 "device extension `ext_shader_atomic_float2`",
1629 ]));
1630 }
1631 }
1632 "SPV_EXT_shader_atomic_float16_add" => {
1633 if !(device.enabled_extensions().ext_shader_atomic_float2) {
1634 return Err(ShaderSupportError::RequirementsNotMet(&[
1635 "device extension `ext_shader_atomic_float2`",
1636 ]));
1637 }
1638 }
1639 "SPV_KHR_integer_dot_product" => {
1640 if !(device.api_version() >= Version::V1_1
1641 || device.enabled_extensions().khr_shader_integer_dot_product)
1642 {
1643 return Err(ShaderSupportError::RequirementsNotMet(&[
1644 "Vulkan API version 1.1",
1645 "device extension `khr_shader_integer_dot_product`",
1646 ]));
1647 }
1648 }
1649 "SPV_INTEL_shader_integer_functions" => {
1650 if !(device.enabled_extensions().intel_shader_integer_functions2) {
1651 return Err(ShaderSupportError::RequirementsNotMet(&[
1652 "device extension `intel_shader_integer_functions2`",
1653 ]));
1654 }
1655 }
1656 "SPV_KHR_device_group" => {
1657 if !(device.api_version() >= Version::V1_1
1658 || device.enabled_extensions().khr_device_group)
1659 {
1660 return Err(ShaderSupportError::RequirementsNotMet(&[
1661 "Vulkan API version 1.1",
1662 "device extension `khr_device_group`",
1663 ]));
1664 }
1665 }
1666 "SPV_QCOM_image_processing" => {
1667 if !(device.enabled_extensions().qcom_image_processing) {
1668 return Err(ShaderSupportError::RequirementsNotMet(&[
1669 "device extension `qcom_image_processing`",
1670 ]));
1671 }
1672 }
1673 "SPV_EXT_mesh_shader" => {
1674 if !(device.enabled_extensions().ext_mesh_shader) {
1675 return Err(ShaderSupportError::RequirementsNotMet(&[
1676 "device extension `ext_mesh_shader`",
1677 ]));
1678 }
1679 }
1680 _ => return Err(ShaderSupportError::NotSupportedByVulkan),
1681 }
1682 Ok(())
1683 }
1684