|
|
|
|
Quelle adapter.rs
Sprache: unbekannt
|
|
use super::conv;
use ash::{amd, ext, google, khr, vk};
use parking_lot::Mutex;
use std::{collections::BTreeMap, ffi::CStr, sync::Arc};
fn depth_stencil_required_flags() -> vk::FormatFeatureFlags {
vk::FormatFeatureFlags::SAMPLED_IMAGE | vk::FormatFeatureFlags::DEPTH_STENCIL_ATTA CHMENT
}
//TODO: const fn?
fn indexing_features() -> wgt::Features {
wgt::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING
| wgt::Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING
| wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY
}
/// Features supported by a [`vk::PhysicalDevice`] and its extensions.
///
/// This is used in two phases:
///
/// - When enumerating adapters, this represents the features offered by the
/// adapter. [`Instance::expose_adapter`] calls `vkGetPhysicalDeviceFeatures2`
/// (or `vkGetPhysicalDeviceFeatures` if that is not available) to collect
/// this information about the `VkPhysicalDevice` represented by the
/// `wgpu_hal::ExposedAdapter`.
///
/// - When opening a device, this represents the features we would like to
/// enable. At `wgpu_hal::Device` construction time,
/// [`PhysicalDeviceFeatures::from_extensions_and_requested_features`]
/// constructs an value of this type indicating which Vulkan features to
/// enable, based on the `wgpu_types::Features` requested.
///
/// [`Instance::expose_adapter`]: super::Instance::expose_adapter
#[derive(Debug, Default)]
pub struct PhysicalDeviceFeatures {
/// Basic Vulkan 1.0 features.
core: vk::PhysicalDeviceFeatures,
/// Features provided by `VK_EXT_descriptor_indexing`, promoted to Vulkan 1.2.
pub(super) descriptor_indexing:
Option<vk::PhysicalDeviceDescriptorIndexingFeaturesEXT<'static>>,
/// Features provided by `VK_KHR_imageless_framebuffer`, promoted to Vulkan 1.2.
imageless_framebuffer: Option<vk::PhysicalDeviceImagelessFramebufferFeaturesKHR<'static>>,
/// Features provided by `VK_KHR_timeline_semaphore`, promoted to Vulkan 1.2
timeline_semaphore: Option<vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR<'static>>,
/// Features provided by `VK_EXT_image_robustness`, promoted to Vulkan 1.3
image_robustness: Option<vk::PhysicalDeviceImageRobustnessFeaturesEXT<'static>>,
/// Features provided by `VK_EXT_robustness2`.
robustness2: Option<vk::PhysicalDeviceRobustness2FeaturesEXT<'static>>,
/// Features provided by `VK_KHR_multiview`, promoted to Vulkan 1.1.
multiview: Option<vk::PhysicalDeviceMultiviewFeaturesKHR<'static>>,
/// Features provided by `VK_KHR_sampler_ycbcr_conversion`, promoted to Vulkan 1.1.
sampler_ycbcr_conversion: Option<vk::PhysicalDeviceSamplerYcbcrConversionFeatures<'static>>,
/// Features provided by `VK_EXT_texture_compression_astc_hdr`, promoted to Vulkan 1.3.
astc_hdr: Option<vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT<'static>>,
/// Features provided by `VK_KHR_shader_float16_int8` (promoted to Vulkan
/// 1.2) and `VK_KHR_16bit_storage` (promoted to Vulkan 1.1). We use these
/// features together, or not at all.
shader_float16: Option<(
vk::PhysicalDeviceShaderFloat16Int8Features<'static>,
vk::PhysicalDevice16BitStorageFeatures<'static>,
)>,
/// Features provided by `VK_KHR_acceleration_structure`.
acceleration_structure: Option<vk::PhysicalDeviceAccelerationStructureFeaturesKHR<'static>>,
/// Features provided by `VK_KHR_buffer_device_address`, promoted to Vulkan 1.2.
///
/// We only use this feature for
/// [`Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE`], which requires
/// `VK_KHR_acceleration_structure`, which depends on
/// `VK_KHR_buffer_device_address`, so [`Instance::expose_adapter`] only
/// bothers to check if `VK_KHR_acceleration_structure` is available,
/// leaving this `None`.
///
/// However, we do populate this when creating a device if
/// [`Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE`] is requested.
///
/// [`Instance::expose_adapter`]: super::Instance::expose_adapter
/// [`Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE`]: wgt::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE
buffer_device_address: Option<vk::PhysicalDeviceBufferDeviceAddressFeaturesKHR<'static>>,
/// Features provided by `VK_KHR_ray_query`,
///
/// Vulkan requires that the feature be present if the `VK_KHR_ray_query`
/// extension is present, so [`Instance::expose_adapter`] doesn't bother retrieving
/// this from `vkGetPhysicalDeviceFeatures2`.
///
/// However, we do populate this when creating a device if ray tracing is requested.
///
/// [`Instance::expose_adapter`]: super::Instance::expose_adapter
ray_query: Option<vk::PhysicalDeviceRayQueryFeaturesKHR<'static>>,
/// Features provided by `VK_KHR_zero_initialize_workgroup_memory`, promoted
/// to Vulkan 1.3.
zero_initialize_workgroup_memory:
Option<vk::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'static>>,
/// Features provided by `VK_KHR_shader_atomic_int64`, promoted to Vulkan 1.2.
shader_atomic_int64: Option<vk::PhysicalDeviceShaderAtomicInt64Features<'static>>,
/// Features provided by `VK_EXT_shader_atomic_float`.
shader_atomic_float: Option<vk::PhysicalDeviceShaderAtomicFloatFeaturesEXT<'static>>,
/// Features provided by `VK_EXT_subgroup_size_control`, promoted to Vulkan 1.3.
subgroup_size_control: Option<vk::PhysicalDeviceSubgroupSizeControlFeatures<'static>>,
}
impl PhysicalDeviceFeatures {
/// Add the members of `self` into `info.enabled_features` and its `p_next` chain.
pub fn add_to_device_create<'a>(
&'a mut self,
mut info: vk::DeviceCreateInfo<'a>,
) -> vk::DeviceCreateInfo<'a> {
info = info.enabled_features(&self.core);
if let Some(ref mut feature) = self.descriptor_indexing {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.imageless_framebuffer {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.timeline_semaphore {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.image_robustness {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.robustness2 {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.astc_hdr {
info = info.push_next(feature);
}
if let Some((ref mut f16_i8_feature, ref mut _16bit_feature)) = self.shader_float16 {
info = info.push_next(f16_i8_feature);
info = info.push_next(_16bit_feature);
}
if let Some(ref mut feature) = self.zero_initialize_workgroup_memory {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.acceleration_structure {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.buffer_device_address {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.ray_query {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.shader_atomic_int64 {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.shader_atomic_float {
info = info.push_next(feature);
}
if let Some(ref mut feature) = self.subgroup_size_control {
info = info.push_next(feature);
}
info
}
/// Create a `PhysicalDeviceFeatures` that can be used to create a logical
/// device.
///
/// Return a `PhysicalDeviceFeatures` value capturing all the Vulkan
/// features needed for the given [`Features`], [`DownlevelFlags`], and
/// [`PrivateCapabilities`]. You can use the returned value's
/// [`add_to_device_create`] method to configure a
/// [`vk::DeviceCreateInfo`] to build a logical device providing those
/// features.
///
/// To ensure that the returned value is able to select all the Vulkan
/// features needed to express `requested_features`, `downlevel_flags`, and
/// `private_caps`:
///
/// - The given `enabled_extensions` set must include all the extensions
/// selected by [`Adapter::required_device_extensions`] when passed
/// `features`.
///
/// - The given `device_api_version` must be the Vulkan API version of the
/// physical device we will use to create the logical device.
///
/// [`Features`]: wgt::Features
/// [`DownlevelFlags`]: wgt::DownlevelFlags
/// [`PrivateCapabilities`]: super::PrivateCapabilities
/// [`add_to_device_create`]: PhysicalDeviceFeatures::add_to_device_create
/// [`Adapter::required_device_extensions`]: super::Adapter::required_device_extensions
fn from_extensions_and_requested_features(
device_api_version: u32,
enabled_extensions: &[&'static CStr],
requested_features: wgt::Features,
downlevel_flags: wgt::DownlevelFlags,
private_caps: &super::PrivateCapabilities,
) -> Self {
let needs_sampled_image_non_uniform = requested_features.contains(
wgt::Features::TEXTURE_BINDING_ARRAY
| wgt::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
);
let needs_storage_buffer_non_uniform = requested_features.contains(
wgt::Features::BUFFER_BINDING_ARRAY
| wgt::Features::STORAGE_RESOURCE_BINDING_ARRAY
| wgt::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
);
let needs_uniform_buffer_non_uniform = requested_features.contains(
wgt::Features::TEXTURE_BINDING_ARRAY
| wgt::Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
);
let needs_storage_image_non_uniform = requested_features.contains(
wgt::Features::TEXTURE_BINDING_ARRAY
| wgt::Features::STORAGE_RESOURCE_BINDING_ARRAY
| wgt::Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
);
let needs_partially_bound =
requested_features.intersects(wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY);
Self {
// vk::PhysicalDeviceFeatures is a struct composed of Bool32's while
// Features is a bitfield so we need to map everything manually
core: vk::PhysicalDeviceFeatures::default()
.robust_buffer_access(private_caps.robust_buffer_access)
.independent_blend(downlevel_flags.contains(wgt::DownlevelFlags::INDEPENDENT_BLEND))
.sample_rate_shading(
downlevel_flags.contains(wgt::DownlevelFlags::MULTISAMPLED_SHADING),
)
.image_cube_array(
downlevel_flags.contains(wgt::DownlevelFlags::CUBE_ARRAY_TEXTURES),
)
.draw_indirect_first_instance(
requested_features.contains(wgt::Features::INDIRECT_FIRST_INSTANCE),
)
//.dual_src_blend(requested_features.contains(wgt::Features::DUAL_SRC_BLENDING))
.multi_draw_indirect(
requested_features.contains(wgt::Features::MULTI_DRAW_INDIRECT),
)
.fill_mode_non_solid(requested_features.intersects(
wgt::Features::POLYGON_MODE_LINE | wgt::Features::POLYGON_MODE_POINT,
))
//.depth_bounds(requested_features.contains(wgt::Features::DEPTH_BOUNDS))
//.alpha_to_one(requested_features.contains(wgt::Features::ALPHA_TO_ONE))
//.multi_viewport(requested_features.contains(wgt::Features::MULTI_VIEWPORTS))
.sampler_anisotropy(
downlevel_flags.contains(wgt::DownlevelFlags::ANISOTROPIC_FILTERING),
)
.texture_compression_etc2(
requested_features.contains(wgt::Features::TEXTURE_COMPRESSION_ETC2),
)
.texture_compression_astc_ldr(
requested_features.contains(wgt::Features::TEXTURE_COMPRESSION_ASTC),
)
.texture_compression_bc(
requested_features.contains(wgt::Features::TEXTURE_COMPRESSION_BC),
// BC provides formats for Sliced 3D
)
//.occlusion_query_precise(requested_features.contains(wgt::Features::PRECISE_OCCLUSION_QUERY))
.pipeline_statistics_query(
requested_features.contains(wgt::Features::PIPELINE_STATISTICS_QUERY),
)
.vertex_pipeline_stores_and_atomics(
requested_features.contains(wgt::Features::VERTEX_WRITABLE_STORAGE),
)
.fragment_stores_and_atomics(
downlevel_flags.contains(wgt::DownlevelFlags::FRAGMENT_WRITABLE_STORAGE),
)
//.shader_image_gather_extended(
//.shader_storage_image_extended_formats(
.shader_uniform_buffer_array_dynamic_indexing(
requested_features.contains(wgt::Features::BUFFER_BINDING_ARRAY),
)
.shader_storage_buffer_array_dynamic_indexing(requested_features.contains(
wgt::Features::BUFFER_BINDING_ARRAY
| wgt::Features::STORAGE_RESOURCE_BINDING_ARRAY,
))
.shader_sampled_image_array_dynamic_indexing(
requested_features.contains(wgt::Features::TEXTURE_BINDING_ARRAY),
)
.shader_storage_buffer_array_dynamic_indexing(requested_features.contains(
wgt::Features::TEXTURE_BINDING_ARRAY
| wgt::Features::STORAGE_RESOURCE_BINDING_ARRAY,
))
//.shader_storage_image_array_dynamic_indexing(
//.shader_clip_distance(requested_features.contains(wgt::Features::SHADER_CLIP_DISTANCE))
//.shader_cull_distance(requested_features.contains(wgt::Features::SHADER_CULL_DISTANCE))
.shader_float64(requested_features.contains(wgt::Features::SHADER_F64))
.shader_int64(requested_features.contains(wgt::Features::SHADER_INT64))
.shader_int16(requested_features.contains(wgt::Features::SHADER_I16))
//.shader_resource_residency(requested_features.contains(wgt::Features::SHADER_RESOURCE_RESIDENCY))
.geometry_shader(requested_features.contains(wgt::Features::SHADER_PRIMITIVE_INDEX))
.depth_clamp(requested_features.contains(wgt::Features::DEPTH_CLIP_CONTROL))
.dual_src_blend(requested_features.contains(wgt::Features::DUAL_SOURCE_BLENDING)),
descriptor_indexing: if requested_features.intersects(indexing_features()) {
Some(
vk::PhysicalDeviceDescriptorIndexingFeaturesEXT::default()
.shader_sampled_image_array_non_uniform_indexing(
needs_sampled_image_non_uniform,
)
.shader_storage_image_array_non_uniform_indexing(
needs_storage_image_non_uniform,
)
.shader_uniform_buffer_array_non_uniform_indexing(
needs_uniform_buffer_non_uniform,
)
.shader_storage_buffer_array_non_uniform_indexing(
needs_storage_buffer_non_uniform,
)
.descriptor_binding_partially_bound(needs_partially_bound),
)
} else {
None
},
imageless_framebuffer: if device_api_version >= vk::API_VERSION_1_2
|| enabled_extensions.contains(&khr::imageless_framebuffer::NAME)
{
Some(
vk::PhysicalDeviceImagelessFramebufferFeaturesKHR::default()
.imageless_framebuffer(private_caps.imageless_framebuffers),
)
} else {
None
},
timeline_semaphore: if device_api_version >= vk::API_VERSION_1_2
|| enabled_extensions.contains(&khr::timeline_semaphore::NAME)
{
Some(
vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR::default()
.timeline_semaphore(private_caps.timeline_semaphores),
)
} else {
None
},
image_robustness: if device_api_version >= vk::API_VERSION_1_3
|| enabled_extensions.contains(&ext::image_robustness::NAME)
{
Some(
vk::PhysicalDeviceImageRobustnessFeaturesEXT::default()
.robust_image_access(private_caps.robust_image_access),
)
} else {
None
},
robustness2: if enabled_extensions.contains(&ext::robustness2::NAME) {
Some(
vk::PhysicalDeviceRobustness2FeaturesEXT::default()
.robust_buffer_access2(private_caps.robust_buffer_access2)
.robust_image_access2(private_caps.robust_image_access2),
)
} else {
None
},
multiview: if device_api_version >= vk::API_VERSION_1_1
|| enabled_extensions.contains(&khr::multiview::NAME)
{
Some(
vk::PhysicalDeviceMultiviewFeatures::default()
.multiview(requested_features.contains(wgt::Features::MULTIVIEW)),
)
} else {
None
},
sampler_ycbcr_conversion: if device_api_version >= vk::API_VERSION_1_1
|| enabled_extensions.contains(&khr::sampler_ycbcr_conversion::NAME)
{
Some(
vk::PhysicalDeviceSamplerYcbcrConversionFeatures::default(), // .sampler_ycbcr_conversion(requested_features.contains(wgt::Features::TEXTURE_FORMAT_NV12))
)
} else {
None
},
astc_hdr: if enabled_extensions.contains(&ext::texture_compression_astc_hdr::NAME) {
Some(
vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::default()
.texture_compression_astc_hdr(true),
)
} else {
None
},
shader_float16: if requested_features.contains(wgt::Features::SHADER_F16) {
Some((
vk::PhysicalDeviceShaderFloat16Int8Features::default().shader_float16(true),
vk::PhysicalDevice16BitStorageFeatures::default()
.storage_buffer16_bit_access(true)
.uniform_and_storage_buffer16_bit_access(true),
))
} else {
None
},
acceleration_structure: if enabled_extensions
.contains(&khr::acceleration_structure::NAME)
{
Some(
vk::PhysicalDeviceAccelerationStructureFeaturesKHR::default()
.acceleration_structure(true),
)
} else {
None
},
buffer_device_address: if enabled_extensions.contains(&khr::buffer_device_address::NAME)
{
Some(
vk::PhysicalDeviceBufferDeviceAddressFeaturesKHR::default()
.buffer_device_address(true),
)
} else {
None
},
ray_query: if enabled_extensions.contains(&khr::ray_query::NAME) {
Some(vk::PhysicalDeviceRayQueryFeaturesKHR::default().ray_query(true))
} else {
None
},
zero_initialize_workgroup_memory: if device_api_version >= vk::API_VERSION_1_3
|| enabled_extensions.contains(&khr::zero_initialize_workgroup_memory::NAME)
{
Some(
vk::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::default()
.shader_zero_initialize_workgroup_memory(
private_caps.zero_initialize_workgroup_memory,
),
)
} else {
None
},
shader_atomic_int64: if device_api_version >= vk::API_VERSION_1_2
|| enabled_extensions.contains(&khr::shader_atomic_int64::NAME)
{
let needed = requested_features.intersects(
wgt::Features::SHADER_INT64_ATOMIC_ALL_OPS
| wgt::Features::SHADER_INT64_ATOMIC_MIN_MAX,
);
Some(
vk::PhysicalDeviceShaderAtomicInt64Features::default()
.shader_buffer_int64_atomics(needed)
.shader_shared_int64_atomics(needed),
)
} else {
None
},
shader_atomic_float: if enabled_extensions.contains(&ext::shader_atomic_float::NAME) {
let needed = requested_features.contains(wgt::Features::SHADER_FLOAT32_ATOMIC);
Some(
vk::PhysicalDeviceShaderAtomicFloatFeaturesEXT::default()
.shader_buffer_float32_atomics(needed)
.shader_buffer_float32_atomic_add(needed),
)
} else {
None
},
subgroup_size_control: if device_api_version >= vk::API_VERSION_1_3
|| enabled_extensions.contains(&ext::subgroup_size_control::NAME)
{
Some(
vk::PhysicalDeviceSubgroupSizeControlFeatures::default()
.subgroup_size_control(true),
)
} else {
None
},
}
}
/// Compute the wgpu [`Features`] and [`DownlevelFlags`] supported by a physical device.
///
/// Given `self`, together with the instance and physical device it was
/// built from, and a `caps` also built from those, determine which wgpu
/// features and downlevel flags the device can support.
///
/// [`Features`]: wgt::Features
/// [`DownlevelFlags`]: wgt::DownlevelFlags
fn to_wgpu(
&self,
instance: &ash::Instance,
phd: vk::PhysicalDevice,
caps: &PhysicalDeviceProperties,
) -> (wgt::Features, wgt::DownlevelFlags) {
use crate::auxil::db;
use wgt::{DownlevelFlags as Df, Features as F};
let mut features = F::empty()
| F::SPIRV_SHADER_PASSTHROUGH
| F::MAPPABLE_PRIMARY_BUFFERS
| F::PUSH_CONSTANTS
| F::ADDRESS_MODE_CLAMP_TO_BORDER
| F::ADDRESS_MODE_CLAMP_TO_ZERO
| F::TIMESTAMP_QUERY
| F::TIMESTAMP_QUERY_INSIDE_ENCODERS
| F::TIMESTAMP_QUERY_INSIDE_PASSES
| F::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
| F::CLEAR_TEXTURE
| F::PIPELINE_CACHE
| F::TEXTURE_ATOMIC;
let mut dl_flags = Df::COMPUTE_SHADERS
| Df::BASE_VERTEX
| Df::READ_ONLY_DEPTH_STENCIL
| Df::NON_POWER_OF_TWO_MIPMAPPED_TEXTURES
| Df::COMPARISON_SAMPLERS
| Df::VERTEX_STORAGE
| Df::FRAGMENT_STORAGE
| Df::DEPTH_TEXTURE_AND_BUFFER_COPIES
| Df::BUFFER_BINDINGS_NOT_16_BYTE_ALIGNED
| Df::UNRESTRICTED_INDEX_BUFFER
| Df::INDIRECT_EXECUTION
| Df::VIEW_FORMATS
| Df::UNRESTRICTED_EXTERNAL_TEXTURE_COPIES
| Df::NONBLOCKING_QUERY_RESOLVE
| Df::VERTEX_AND_INSTANCE_INDEX_RESPECTS_RESPECTIVE_FIRST_VALUE_IN_INDIRECT_DRAW;
dl_flags.set(
Df::SURFACE_VIEW_FORMATS,
caps.supports_extension(khr::swapchain_mutable_format::NAME),
);
dl_flags.set(Df::CUBE_ARRAY_TEXTURES, self.core.image_cube_array != 0);
dl_flags.set(Df::ANISOTROPIC_FILTERING, self.core.sampler_anisotropy != 0);
dl_flags.set(
Df::FRAGMENT_WRITABLE_STORAGE,
self.core.fragment_stores_and_atomics != 0,
);
dl_flags.set(Df::MULTISAMPLED_SHADING, self.core.sample_rate_shading != 0);
dl_flags.set(Df::INDEPENDENT_BLEND, self.core.independent_blend != 0);
dl_flags.set(
Df::FULL_DRAW_INDEX_UINT32,
self.core.full_draw_index_uint32 != 0,
);
dl_flags.set(Df::DEPTH_BIAS_CLAMP, self.core.depth_bias_clamp != 0);
features.set(
F::INDIRECT_FIRST_INSTANCE,
self.core.draw_indirect_first_instance != 0,
);
//if self.core.dual_src_blend != 0
features.set(F::MULTI_DRAW_INDIRECT, self.core.multi_draw_indirect != 0);
features.set(F::POLYGON_MODE_LINE, self.core.fill_mode_non_solid != 0);
features.set(F::POLYGON_MODE_POINT, self.core.fill_mode_non_solid != 0);
//if self.core.depth_bounds != 0 {
//if self.core.alpha_to_one != 0 {
//if self.core.multi_viewport != 0 {
features.set(
F::TEXTURE_COMPRESSION_ETC2,
self.core.texture_compression_etc2 != 0,
);
features.set(
F::TEXTURE_COMPRESSION_ASTC,
self.core.texture_compression_astc_ldr != 0,
);
features.set(
F::TEXTURE_COMPRESSION_BC,
self.core.texture_compression_bc != 0,
);
features.set(
F::TEXTURE_COMPRESSION_BC_SLICED_3D,
self.core.texture_compression_bc != 0, // BC guarantees Sliced 3D
);
features.set(
F::PIPELINE_STATISTICS_QUERY,
self.core.pipeline_statistics_query != 0,
);
features.set(
F::VERTEX_WRITABLE_STORAGE,
self.core.vertex_pipeline_stores_and_atomics != 0,
);
//if self.core.shader_image_gather_extended != 0 {
//if self.core.shader_storage_image_extended_formats != 0 {
features.set(
F::BUFFER_BINDING_ARRAY,
self.core.shader_uniform_buffer_array_dynamic_indexing != 0,
);
features.set(
F::TEXTURE_BINDING_ARRAY,
self.core.shader_sampled_image_array_dynamic_indexing != 0,
);
features.set(F::SHADER_PRIMITIVE_INDEX, self.core.geometry_shader != 0);
features.set(
F::STORAGE_RESOURCE_BINDING_ARRAY,
(features.contains(F::BUFFER_BINDING_ARRAY)
&& self.core.shader_storage_buffer_array_dynamic_indexing != 0)
|| (features.contains(F::TEXTURE_BINDING_ARRAY)
&& self.core.shader_storage_image_array_dynamic_indexing != 0),
);
//if self.core.shader_storage_image_array_dynamic_indexing != 0 {
//if self.core.shader_clip_distance != 0 {
//if self.core.shader_cull_distance != 0 {
features.set(F::SHADER_F64, self.core.shader_float64 != 0);
features.set(F::SHADER_INT64, self.core.shader_int64 != 0);
features.set(F::SHADER_I16, self.core.shader_int16 != 0);
if let Some(ref shader_atomic_int64) = self.shader_atomic_int64 {
features.set(
F::SHADER_INT64_ATOMIC_ALL_OPS | F::SHADER_INT64_ATOMIC_MIN_MAX,
shader_atomic_int64.shader_buffer_int64_atomics != 0
&& shader_atomic_int64.shader_shared_int64_atomics != 0,
);
}
if let Some(ref shader_atomic_float) = self.shader_atomic_float {
features.set(
F::SHADER_FLOAT32_ATOMIC,
shader_atomic_float.shader_buffer_float32_atomics != 0
&& shader_atomic_float.shader_buffer_float32_atomic_add != 0,
);
}
//if caps.supports_extension(khr::sampler_mirror_clamp_to_edge::NAME) {
//if caps.supports_extension(ext::sampler_filter_minmax::NAME) {
features.set(
F::MULTI_DRAW_INDIRECT_COUNT,
caps.supports_extension(khr::draw_indirect_count::NAME),
);
features.set(
F::CONSERVATIVE_RASTERIZATION,
caps.supports_extension(ext::conservative_rasterization::NAME),
);
let intel_windows = caps.properties.vendor_id == db::intel::VENDOR && cfg!(windows);
if let Some(ref descriptor_indexing) = self.descriptor_indexing {
const STORAGE: F = F::STORAGE_RESOURCE_BINDING_ARRAY;
features.set(
F::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
(features.contains(F::TEXTURE_BINDING_ARRAY)
&& descriptor_indexing.shader_sampled_image_array_non_uniform_indexing != 0)
&& (features.contains(F::BUFFER_BINDING_ARRAY | STORAGE)
&& descriptor_indexing.shader_storage_buffer_array_non_uniform_indexing
!= 0),
);
features.set(
F::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
(features.contains(F::BUFFER_BINDING_ARRAY)
&& descriptor_indexing.shader_uniform_buffer_array_non_uniform_indexing != 0)
&& (features.contains(F::TEXTURE_BINDING_ARRAY | STORAGE)
&& descriptor_indexing.shader_storage_image_array_non_uniform_indexing
!= 0),
);
if descriptor_indexing.descriptor_binding_partially_bound != 0 && !intel_windows {
features |= F::PARTIALLY_BOUND_BINDING_ARRAY;
}
}
features.set(F::DEPTH_CLIP_CONTROL, self.core.depth_clamp != 0);
features.set(F::DUAL_SOURCE_BLENDING, self.core.dual_src_blend != 0);
if let Some(ref multiview) = self.multiview {
features.set(F::MULTIVIEW, multiview.multiview != 0);
}
features.set(
F::TEXTURE_FORMAT_16BIT_NORM,
is_format_16bit_norm_supported(instance, phd),
);
if let Some(ref astc_hdr) = self.astc_hdr {
features.set(
F::TEXTURE_COMPRESSION_ASTC_HDR,
astc_hdr.texture_compression_astc_hdr != 0,
);
}
if let Some((ref f16_i8, ref bit16)) = self.shader_float16 {
features.set(
F::SHADER_F16,
f16_i8.shader_float16 != 0
&& bit16.storage_buffer16_bit_access != 0
&& bit16.uniform_and_storage_buffer16_bit_access != 0,
);
}
if let Some(ref subgroup) = caps.subgroup {
if (caps.device_api_version >= vk::API_VERSION_1_3
|| caps.supports_extension(ext::subgroup_size_control::NAME))
&& subgroup.supported_operations.contains(
vk::SubgroupFeatureFlags::BASIC
| vk::SubgroupFeatureFlags::VOTE
| vk::SubgroupFeatureFlags::ARITHMETIC
| vk::SubgroupFeatureFlags::BALLOT
| vk::SubgroupFeatureFlags::SHUFFLE
| vk::SubgroupFeatureFlags::SHUFFLE_RELATIVE,
)
{
features.set(
F::SUBGROUP,
subgroup
.supported_stages
.contains(vk::ShaderStageFlags::COMPUTE | vk::ShaderStageFlags::FRAGMENT),
);
features.set(
F::SUBGROUP_VERTEX,
subgroup
.supported_stages
.contains(vk::ShaderStageFlags::VERTEX),
);
features.insert(F::SUBGROUP_BARRIER);
}
}
let supports_depth_format = |format| {
supports_format(
instance,
phd,
format,
vk::ImageTiling::OPTIMAL,
depth_stencil_required_flags(),
)
};
let texture_s8 = supports_depth_format(vk::Format::S8_UINT);
let texture_d32 = supports_depth_format(vk::Format::D32_SFLOAT);
let texture_d24_s8 = supports_depth_format(vk::Format::D24_UNORM_S8_UINT);
let texture_d32_s8 = supports_depth_format(vk::Format::D32_SFLOAT_S8_UINT);
let stencil8 = texture_s8 || texture_d24_s8;
let depth24_plus_stencil8 = texture_d24_s8 || texture_d32_s8;
dl_flags.set(
Df::WEBGPU_TEXTURE_FORMAT_SUPPORT,
stencil8 && depth24_plus_stencil8 && texture_d32,
);
features.set(F::DEPTH32FLOAT_STENCIL8, texture_d32_s8);
features.set(
F::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE,
caps.supports_extension(khr::deferred_host_operations::NAME)
&& caps.supports_extension(khr::acceleration_structure::NAME)
&& caps.supports_extension(khr::buffer_device_address::NAME),
);
features.set(
F::EXPERIMENTAL_RAY_QUERY,
caps.supports_extension(khr::ray_query::NAME),
);
let rg11b10ufloat_renderable = supports_format(
instance,
phd,
vk::Format::B10G11R11_UFLOAT_PACK32,
vk::ImageTiling::OPTIMAL,
vk::FormatFeatureFlags::COLOR_ATTACHMENT
| vk::FormatFeatureFlags::COLOR_ATTACHMENT_BLEND,
);
features.set(F::RG11B10UFLOAT_RENDERABLE, rg11b10ufloat_renderable);
features.set(
F::BGRA8UNORM_STORAGE,
supports_bgra8unorm_storage(instance, phd, caps.device_api_version),
);
features.set(
F::FLOAT32_FILTERABLE,
is_float32_filterable_supported(instance, phd),
);
if let Some(ref _sampler_ycbcr_conversion) = self.sampler_ycbcr_conversion {
features.set(
F::TEXTURE_FORMAT_NV12,
supports_format(
instance,
phd,
vk::Format::G8_B8R8_2PLANE_420_UNORM,
vk::ImageTiling::OPTIMAL,
vk::FormatFeatureFlags::SAMPLED_IMAGE
| vk::FormatFeatureFlags::TRANSFER_SRC
| vk::FormatFeatureFlags::TRANSFER_DST,
) && !caps
.driver
.map(|driver| driver.driver_id == vk::DriverId::MOLTENVK)
.unwrap_or_default(),
);
}
features.set(
F::VULKAN_GOOGLE_DISPLAY_TIMING,
caps.supports_extension(google::display_timing::NAME),
);
features.set(
F::VULKAN_EXTERNAL_MEMORY_WIN32,
caps.supports_extension(khr::external_memory_win32::NAME),
);
(features, dl_flags)
}
}
/// Vulkan "properties" structures gathered about a physical device.
///
/// This structure holds the properties of a [`vk::PhysicalDevice`]:
/// - the standard Vulkan device properties
/// - the `VkExtensionProperties` structs for all available extensions, and
/// - the per-extension properties structures for the available extensions that
/// `wgpu` cares about.
///
/// Generally, if you get it from any of these functions, it's stored
/// here:
/// - `vkEnumerateDeviceExtensionProperties`
/// - `vkGetPhysicalDeviceProperties`
/// - `vkGetPhysicalDeviceProperties2`
///
/// This also includes a copy of the device API version, since we can
/// use that as a shortcut for searching for an extension, if the
/// extension has been promoted to core in the current version.
///
/// This does not include device features; for those, see
/// [`PhysicalDeviceFeatures`].
#[derive(Default, Debug)]
pub struct PhysicalDeviceProperties {
/// Extensions supported by the `vk::PhysicalDevice`,
/// as returned by `vkEnumerateDeviceExtensionProperties`.
supported_extensions: Vec<vk::ExtensionProperties>,
/// Properties of the `vk::PhysicalDevice`, as returned by
/// `vkGetPhysicalDeviceProperties`.
properties: vk::PhysicalDeviceProperties,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_KHR_maintenance3` extension, promoted to Vulkan 1.1.
maintenance_3: Option<vk::PhysicalDeviceMaintenance3Properties<'static>>,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_EXT_descriptor_indexing` extension, promoted to Vulkan 1.2.
descriptor_indexing: Option<vk::PhysicalDeviceDescriptorIndexingPropertiesEXT<'static>>,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_KHR_acceleration_structure` extension.
acceleration_structure: Option<vk::PhysicalDeviceAccelerationStructurePropertiesKHR<'static>>,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_KHR_driver_properties` extension, promoted to Vulkan 1.2.
driver: Option<vk::PhysicalDeviceDriverPropertiesKHR<'static>>,
/// Additional `vk::PhysicalDevice` properties from Vulkan 1.1.
subgroup: Option<vk::PhysicalDeviceSubgroupProperties<'static>>,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_EXT_subgroup_size_control` extension, promoted to Vulkan 1.3.
subgroup_size_control: Option<vk::PhysicalDeviceSubgroupSizeControlProperties<'static>>,
/// Additional `vk::PhysicalDevice` properties from the
/// `VK_EXT_robustness2` extension.
robustness2: Option<vk::PhysicalDeviceRobustness2PropertiesEXT<'static>>,
/// The device API version.
///
/// Which is the version of Vulkan supported for device-level functionality.
///
/// It is associated with a `VkPhysicalDevice` and its children.
device_api_version: u32,
}
impl PhysicalDeviceProperties {
pub fn properties(&self) -> vk::PhysicalDeviceProperties {
self.properties
}
pub fn supports_extension(&self, extension: &CStr) -> bool {
self.supported_extensions
.iter()
.any(|ep| ep.extension_name_as_c_str() == Ok(extension))
}
/// Map `requested_features` to the list of Vulkan extension strings required to create the logical device.
fn get_required_extensions(&self, requested_features: wgt::Features) -> Vec<&'static CStr> {
let mut extensions = Vec::new();
// Note that quite a few extensions depend on the `VK_KHR_get_physical_device_properties2` instance extension.
// We enable `VK_KHR_get_physical_device_properties2` unconditionally (if available).
// Require `VK_KHR_swapchain`
extensions.push(khr::swapchain::NAME);
if self.device_api_version < vk::API_VERSION_1_1 {
// Require either `VK_KHR_maintenance1` or `VK_AMD_negative_viewport_height`
if self.supports_extension(khr::maintenance1::NAME) {
extensions.push(khr::maintenance1::NAME);
} else {
// `VK_AMD_negative_viewport_height` is obsoleted by `VK_KHR_maintenance1` and must not be enabled alongside it
extensions.push(amd::negative_viewport_height::NAME);
}
// Optional `VK_KHR_maintenance2`
if self.supports_extension(khr::maintenance2::NAME) {
extensions.push(khr::maintenance2::NAME);
}
// Optional `VK_KHR_maintenance3`
if self.supports_extension(khr::maintenance3::NAME) {
extensions.push(khr::maintenance3::NAME);
}
// Require `VK_KHR_storage_buffer_storage_class`
extensions.push(khr::storage_buffer_storage_class::NAME);
// Require `VK_KHR_multiview` if the associated feature was requested
if requested_features.contains(wgt::Features::MULTIVIEW) {
extensions.push(khr::multiview::NAME);
}
// Require `VK_KHR_sampler_ycbcr_conversion` if the associated feature was requested
if requested_features.contains(wgt::Features::TEXTURE_FORMAT_NV12) {
extensions.push(khr::sampler_ycbcr_conversion::NAME);
}
}
if self.device_api_version < vk::API_VERSION_1_2 {
// Optional `VK_KHR_image_format_list`
if self.supports_extension(khr::image_format_list::NAME) {
extensions.push(khr::image_format_list::NAME);
}
// Optional `VK_KHR_imageless_framebuffer`
if self.supports_extension(khr::imageless_framebuffer::NAME) {
extensions.push(khr::imageless_framebuffer::NAME);
// Require `VK_KHR_maintenance2` due to it being a dependency
if self.device_api_version < vk::API_VERSION_1_1 {
extensions.push(khr::maintenance2::NAME);
}
}
// Optional `VK_KHR_driver_properties`
if self.supports_extension(khr::driver_properties::NAME) {
extensions.push(khr::driver_properties::NAME);
}
// Optional `VK_KHR_timeline_semaphore`
if self.supports_extension(khr::timeline_semaphore::NAME) {
extensions.push(khr::timeline_semaphore::NAME);
}
// Require `VK_EXT_descriptor_indexing` if one of the associated features was requested
if requested_features.intersects(indexing_features()) {
extensions.push(ext::descriptor_indexing::NAME);
}
// Require `VK_KHR_shader_float16_int8` and `VK_KHR_16bit_storage` if the associated feature was requested
if requested_features.contains(wgt::Features::SHADER_F16) {
extensions.push(khr::shader_float16_int8::NAME);
// `VK_KHR_16bit_storage` requires `VK_KHR_storage_buffer_storage_class`, however we require that one already
if self.device_api_version < vk::API_VERSION_1_1 {
extensions.push(khr::_16bit_storage::NAME);
}
}
//extensions.push(khr::sampler_mirror_clamp_to_edge::NAME);
//extensions.push(ext::sampler_filter_minmax::NAME);
}
if self.device_api_version < vk::API_VERSION_1_3 {
// Optional `VK_EXT_image_robustness`
if self.supports_extension(ext::image_robustness::NAME) {
extensions.push(ext::image_robustness::NAME);
}
// Require `VK_EXT_subgroup_size_control` if the associated feature was requested
if requested_features.contains(wgt::Features::SUBGROUP) {
extensions.push(ext::subgroup_size_control::NAME);
}
}
// Optional `VK_KHR_swapchain_mutable_format`
if self.supports_extension(khr::swapchain_mutable_format::NAME) {
extensions.push(khr::swapchain_mutable_format::NAME);
}
// Optional `VK_EXT_robustness2`
if self.supports_extension(ext::robustness2::NAME) {
extensions.push(ext::robustness2::NAME);
}
// Optional `VK_KHR_external_memory_win32`
if self.supports_extension(khr::external_memory_win32::NAME) {
extensions.push(khr::external_memory_win32::NAME);
}
// Require `VK_KHR_draw_indirect_count` if the associated feature was requested
// Even though Vulkan 1.2 has promoted the extension to core, we must require the extension to avoid
// large amounts of spaghetti involved with using PhysicalDeviceVulkan12Features.
if requested_features.contains(wgt::Features::MULTI_DRAW_INDIRECT_COUNT) {
extensions.push(khr::draw_indirect_count::NAME);
}
// Require `VK_KHR_deferred_host_operations`, `VK_KHR_acceleration_structure` and `VK_KHR_buffer_device_address` if the feature `RAY_TRACING` was requested
if requested_features
.contains(wgt::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE)
{
extensions.push(khr::deferred_host_operations::NAME);
extensions.push(khr::acceleration_structure::NAME);
extensions.push(khr::buffer_device_address::NAME);
}
// Require `VK_KHR_ray_query` if the associated feature was requested
if requested_features.contains(wgt::Features::EXPERIMENTAL_RAY_QUERY) {
extensions.push(khr::ray_query::NAME);
}
// Require `VK_EXT_conservative_rasterization` if the associated feature was requested
if requested_features.contains(wgt::Features::CONSERVATIVE_RASTERIZATION) {
extensions.push(ext::conservative_rasterization::NAME);
}
// Require `VK_KHR_portability_subset` on macOS/iOS
#[cfg(target_vendor = "apple")]
extensions.push(khr::portability_subset::NAME);
// Require `VK_EXT_texture_compression_astc_hdr` if the associated feature was requested
if requested_features.contains(wgt::Features::TEXTURE_COMPRESSION_ASTC_HDR) {
extensions.push(ext::texture_compression_astc_hdr::NAME);
}
// Require `VK_KHR_shader_atomic_int64` if the associated feature was requested
if requested_features.intersects(
wgt::Features::SHADER_INT64_ATOMIC_ALL_OPS | wgt::Features::SHADER_INT64_ATOMIC_MIN_MAX,
) {
extensions.push(khr::shader_atomic_int64::NAME);
}
// Require `VK_EXT_shader_atomic_float` if the associated feature was requested
if requested_features.contains(wgt::Features::SHADER_FLOAT32_ATOMIC) {
extensions.push(ext::shader_atomic_float::NAME);
}
// Require VK_GOOGLE_display_timing if the associated feature was requested
if requested_features.contains(wgt::Features::VULKAN_GOOGLE_DISPLAY_TIMING) {
extensions.push(google::display_timing::NAME);
}
extensions
}
fn to_wgpu_limits(&self) -> wgt::Limits {
let limits = &self.properties.limits;
let max_compute_workgroup_sizes = limits.max_compute_work_group_size;
let max_compute_workgroups_per_dimension = limits.max_compute_work_group_count[0]
.min(limits.max_compute_work_group_count[1])
.min(limits.max_compute_work_group_count[2]);
// Prevent very large buffers on mesa and most android devices.
let is_nvidia = self.properties.vendor_id == crate::auxil::db::nvidia::VENDOR;
let max_buffer_size =
if (cfg!(target_os = "linux") || cfg!(target_os = "android")) && !is_nvidia {
i32::MAX as u64
} else {
u64::MAX
};
// TODO: programmatically determine this, if possible. It's unclear whether we can
// as of https://github.com/gpuweb/gpuweb/issues/2965#issuecomment-1361315447.
//
// In theory some tilers may not support this much. We can't tell however, and
// the driver will throw a DEVICE_REMOVED if it goes too high in usage. This is fine.
//
// 16 bytes per sample is the maximum size for a color attachment.
let max_color_attachment_bytes_per_sample =
limits.max_color_attachments * wgt::TextureFormat::MAX_TARGET_PIXEL_BYTE_COST;
wgt::Limits {
max_texture_dimension_1d: limits.max_image_dimension1_d,
max_texture_dimension_2d: limits.max_image_dimension2_d,
max_texture_dimension_3d: limits.max_image_dimension3_d,
max_texture_array_layers: limits.max_image_array_layers,
max_bind_groups: limits
.max_bound_descriptor_sets
.min(crate::MAX_BIND_GROUPS as u32),
max_bindings_per_bind_group: wgt::Limits::default().max_bindings_per_bind_group,
max_dynamic_uniform_buffers_per_pipeline_layout: limits
.max_descriptor_set_uniform_buffers_dynamic,
max_dynamic_storage_buffers_per_pipeline_layout: limits
.max_descriptor_set_storage_buffers_dynamic,
max_sampled_textures_per_shader_stage: limits.max_per_stage_descriptor_sampled_images,
max_samplers_per_shader_stage: limits.max_per_stage_descriptor_samplers,
max_storage_buffers_per_shader_stage: limits.max_per_stage_descriptor_storage_buffers,
max_storage_textures_per_shader_stage: limits.max_per_stage_descriptor_storage_images,
max_uniform_buffers_per_shader_stage: limits.max_per_stage_descriptor_uniform_buffers,
max_uniform_buffer_binding_size: limits
.max_uniform_buffer_range
.min(crate::auxil::MAX_I32_BINDING_SIZE),
max_storage_buffer_binding_size: limits
.max_storage_buffer_range
.min(crate::auxil::MAX_I32_BINDING_SIZE),
max_vertex_buffers: limits
.max_vertex_input_bindings
.min(crate::MAX_VERTEX_BUFFERS as u32),
max_vertex_attributes: limits.max_vertex_input_attributes,
max_vertex_buffer_array_stride: limits.max_vertex_input_binding_stride,
min_subgroup_size: self
.subgroup_size_control
.map(|subgroup_size| subgroup_size.min_subgroup_size)
.unwrap_or(0),
max_subgroup_size: self
.subgroup_size_control
.map(|subgroup_size| subgroup_size.max_subgroup_size)
.unwrap_or(0),
max_push_constant_size: limits.max_push_constants_size,
min_uniform_buffer_offset_alignment: limits.min_uniform_buffer_offset_alignment as u32,
min_storage_buffer_offset_alignment: limits.min_storage_buffer_offset_alignment as u32,
max_inter_stage_shader_components: limits
.max_vertex_output_components
.min(limits.max_fragment_input_components),
max_color_attachments: limits
.max_color_attachments
.min(crate::MAX_COLOR_ATTACHMENTS as u32),
max_color_attachment_bytes_per_sample,
max_compute_workgroup_storage_size: limits.max_compute_shared_memory_size,
max_compute_invocations_per_workgroup: limits.max_compute_work_group_invocations,
max_compute_workgroup_size_x: max_compute_workgroup_sizes[0],
max_compute_workgroup_size_y: max_compute_workgroup_sizes[1],
max_compute_workgroup_size_z: max_compute_workgroup_sizes[2],
max_compute_workgroups_per_dimension,
max_buffer_size,
max_non_sampler_bindings: u32::MAX,
}
}
/// Return a `wgpu_hal::Alignments` structure describing this adapter.
///
/// The `using_robustness2` argument says how this adapter will implement
/// `wgpu_hal`'s guarantee that shaders can only read the [accessible
/// region][ar] of bindgroup's buffer bindings:
///
/// - If this adapter will depend on `VK_EXT_robustness2`'s
/// `robustBufferAccess2` feature to apply bounds checks to shader buffer
/// access, `using_robustness2` must be `true`.
///
/// - Otherwise, this adapter must use Naga to inject bounds checks on
/// buffer accesses, and `using_robustness2` must be `false`.
///
/// [ar]: ../../struct.BufferBinding.html#accessible-region
fn to_hal_alignments(&self, using_robustness2: bool) -> crate::Alignments {
let limits = &self.properties.limits;
crate::Alignments {
buffer_copy_offset: wgt::BufferSize::new(limits.optimal_buffer_copy_offset_alignment)
.unwrap(),
buffer_copy_pitch: wgt::BufferSize::new(limits.optimal_buffer_copy_row_pitch_alignment)
.unwrap(),
uniform_bounds_check_alignment: {
let alignment = if using_robustness2 {
self.robustness2
.unwrap() // if we're using it, we should have its properties
.robust_uniform_buffer_access_size_alignment
} else {
// If the `robustness2` properties are unavailable, then `robustness2` is not available either Naga-injected bounds checks are precise.
1
};
wgt::BufferSize::new(alignment).unwrap()
},
raw_tlas_instance_size: 64,
ray_tracing_scratch_buffer_alignment: self.acceleration_structure.map_or(
0,
|acceleration_structure| {
acceleration_structure.min_acceleration_structure_scratch_offset_alignment
},
),
}
}
}
impl super::InstanceShared {
fn inspect(
&self,
phd: vk::PhysicalDevice,
) -> (PhysicalDeviceProperties, PhysicalDeviceFeatures) {
let capabilities = {
let mut capabilities = PhysicalDeviceProperties::default();
capabilities.supported_extensions =
unsafe { self.raw.enumerate_device_extension_properties(phd).unwrap() };
capabilities.properties = unsafe { self.raw.get_physical_device_properties(phd) };
capabilities.device_api_version = capabilities.properties.api_version;
if let Some(ref get_device_properties) = self.get_physical_device_properties {
// Get these now to avoid borrowing conflicts later
let supports_maintenance3 = capabilities.device_api_version >= vk::API_VERSION_1_1
|| capabilities.supports_extension(khr::maintenance3::NAME);
let supports_descriptor_indexing = capabilities.device_api_version
>= vk::API_VERSION_1_2
|| capabilities.supports_extension(ext::descriptor_indexing::NAME);
let supports_driver_properties = capabilities.device_api_version
>= vk::API_VERSION_1_2
|| capabilities.supports_extension(khr::driver_properties::NAME);
let supports_subgroup_size_control = capabilities.device_api_version
>= vk::API_VERSION_1_3
|| capabilities.supports_extension(ext::subgroup_size_control::NAME);
let supports_robustness2 = capabilities.supports_extension(ext::robustness2::NAME);
let supports_acceleration_structure =
capabilities.supports_extension(khr::acceleration_structure::NAME);
let mut properties2 = vk::PhysicalDeviceProperties2KHR::default();
if supports_maintenance3 {
let next = capabilities
.maintenance_3
.insert(vk::PhysicalDeviceMaintenance3Properties::default());
properties2 = properties2.push_next(next);
}
if supports_descriptor_indexing {
let next = capabilities
.descriptor_indexing
.insert(vk::PhysicalDeviceDescriptorIndexingPropertiesEXT::default());
properties2 = properties2.push_next(next);
}
if supports_acceleration_structure {
let next = capabilities
.acceleration_structure
.insert(vk::PhysicalDeviceAccelerationStructurePropertiesKHR::default());
properties2 = properties2.push_next(next);
}
if supports_driver_properties {
let next = capabilities
.driver
.insert(vk::PhysicalDeviceDriverPropertiesKHR::default());
properties2 = properties2.push_next(next);
}
if capabilities.device_api_version >= vk::API_VERSION_1_1 {
let next = capabilities
.subgroup
.insert(vk::PhysicalDeviceSubgroupProperties::default());
properties2 = properties2.push_next(next);
}
if supports_subgroup_size_control {
let next = capabilities
.subgroup_size_control
.insert(vk::PhysicalDeviceSubgroupSizeControlProperties::default());
properties2 = properties2.push_next(next);
}
if supports_robustness2 {
let next = capabilities
.robustness2
.insert(vk::PhysicalDeviceRobustness2PropertiesEXT::default());
properties2 = properties2.push_next(next);
}
unsafe {
get_device_properties.get_physical_device_properties2(phd, &mut properties2)
};
if is_intel_igpu_outdated_for_robustness2(
capabilities.properties,
capabilities.driver,
) {
capabilities
.supported_extensions
.retain(|&x| x.extension_name_as_c_str() != Ok(ext::robustness2::NAME));
capabilities.robustness2 = None;
}
};
capabilities
};
let mut features = PhysicalDeviceFeatures::default();
features.core = if let Some(ref get_device_properties) = self.get_physical_device_properties
{
let core = vk::PhysicalDeviceFeatures::default();
let mut features2 = vk::PhysicalDeviceFeatures2KHR::default().features(core);
// `VK_KHR_multiview` is promoted to 1.1
if capabilities.device_api_version >= vk::API_VERSION_1_1
|| capabilities.supports_extension(khr::multiview::NAME)
{
let next = features
.multiview
.insert(vk::PhysicalDeviceMultiviewFeatures::default());
features2 = features2.push_next(next);
}
// `VK_KHR_sampler_ycbcr_conversion` is promoted to 1.1
if capabilities.device_api_version >= vk::API_VERSION_1_1
|| capabilities.supports_extension(khr::sampler_ycbcr_conversion::NAME)
{
let next = features
.sampler_ycbcr_conversion
.insert(vk::PhysicalDeviceSamplerYcbcrConversionFeatures::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(ext::descriptor_indexing::NAME) {
let next = features
.descriptor_indexing
.insert(vk::PhysicalDeviceDescriptorIndexingFeaturesEXT::default());
features2 = features2.push_next(next);
}
// `VK_KHR_imageless_framebuffer` is promoted to 1.2, but has no
// changes, so we can keep using the extension unconditionally.
if capabilities.supports_extension(khr::imageless_framebuffer::NAME) {
let next = features
.imageless_framebuffer
.insert(vk::PhysicalDeviceImagelessFramebufferFeaturesKHR::default());
features2 = features2.push_next(next);
}
// `VK_KHR_timeline_semaphore` is promoted to 1.2, but has no
// changes, so we can keep using the extension unconditionally.
if capabilities.supports_extension(khr::timeline_semaphore::NAME) {
let next = features
.timeline_semaphore
.insert(vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR::default());
features2 = features2.push_next(next);
}
// `VK_KHR_shader_atomic_int64` is promoted to 1.2, but has no
// changes, so we can keep using the extension unconditionally.
if capabilities.device_api_version >= vk::API_VERSION_1_2
|| capabilities.supports_extension(khr::shader_atomic_int64::NAME)
{
let next = features
.shader_atomic_int64
.insert(vk::PhysicalDeviceShaderAtomicInt64Features::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(ext::shader_atomic_float::NAME) {
let next = features
.shader_atomic_float
.insert(vk::PhysicalDeviceShaderAtomicFloatFeaturesEXT::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(ext::image_robustness::NAME) {
let next = features
.image_robustness
.insert(vk::PhysicalDeviceImageRobustnessFeaturesEXT::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(ext::robustness2::NAME) {
let next = features
.robustness2
.insert(vk::PhysicalDeviceRobustness2FeaturesEXT::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(ext::texture_compression_astc_hdr::NAME) {
let next = features
.astc_hdr
.insert(vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::default());
features2 = features2.push_next(next);
}
if capabilities.supports_extension(khr::shader_float16_int8::NAME)
&& capabilities.supports_extension(khr::_16bit_storage::NAME)
{
let next = features.shader_float16.insert((
vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR::default(),
vk::PhysicalDevice16BitStorageFeaturesKHR::default(),
));
features2 = features2.push_next(&mut next.0);
features2 = features2.push_next(&mut next.1);
}
if capabilities.supports_extension(khr::acceleration_structure::NAME) {
let next = features
.acceleration_structure
.insert(vk::PhysicalDeviceAccelerationStructureFeaturesKHR::default());
features2 = features2.push_next(next);
}
// `VK_KHR_zero_initialize_workgroup_memory` is promoted to 1.3
if capabilities.device_api_version >= vk::API_VERSION_1_3
|| capabilities.supports_extension(khr::zero_initialize_workgroup_memory::NAME)
{
let next = features
.zero_initialize_workgroup_memory
.insert(vk::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::default());
features2 = features2.push_next(next);
}
// `VK_EXT_subgroup_size_control` is promoted to 1.3
if capabilities.device_api_version >= vk::API_VERSION_1_3
|| capabilities.supports_extension(ext::subgroup_size_control::NAME)
{
let next = features
.subgroup_size_control
.insert(vk::PhysicalDeviceSubgroupSizeControlFeatures::default());
features2 = features2.push_next(next);
}
unsafe { get_device_properties.get_physical_device_features2(phd, &mut features2) };
features2.features
} else {
unsafe { self.raw.get_physical_device_features(phd) }
};
(capabilities, features)
}
}
impl super::Instance {
pub fn expose_adapter(
&self,
phd: vk::PhysicalDevice,
) -> Option<crate::ExposedAdapter<super::Api>> {
use crate::auxil::db;
let (phd_capabilities, phd_features) = self.shared.inspect(phd);
let info = wgt::AdapterInfo {
name: {
phd_capabilities
.properties
.device_name_as_c_str()
.ok()
.and_then(|name| name.to_str().ok())
.unwrap_or("?")
.to_owned()
},
vendor: phd_capabilities.properties.vendor_id,
device: phd_capabilities.properties.device_id,
device_type: match phd_capabilities.properties.device_type {
vk::PhysicalDeviceType::OTHER => wgt::DeviceType::Other,
vk::PhysicalDeviceType::INTEGRATED_GPU => wgt::DeviceType::IntegratedGpu,
vk::PhysicalDeviceType::DISCRETE_GPU => wgt::DeviceType::DiscreteGpu,
--> --------------------
--> maximum size reached
--> --------------------
[ Dauer der Verarbeitung: 0.43 Sekunden
(vorverarbeitet)
]
|
2026-04-02
|
|
|
|
|
