98 lines
3.5 KiB
Rust
98 lines
3.5 KiB
Rust
use ash::{Entry, vk};
|
|
use std::ffi::CStr;
|
|
|
|
pub fn report() {
|
|
let entry = match unsafe { Entry::load() } {
|
|
Ok(e) => e,
|
|
Err(e) => {
|
|
println!("\nraw vulkan: cannot load loader -- {e}");
|
|
return;
|
|
}
|
|
};
|
|
|
|
let instance_version = match unsafe { entry.try_enumerate_instance_version() } {
|
|
Ok(Some(v)) => v,
|
|
Ok(None) => vk::API_VERSION_1_0,
|
|
Err(e) => {
|
|
println!("\nraw vulkan: enumerate_instance_version failed -- {e}");
|
|
return;
|
|
}
|
|
};
|
|
println!("\nraw vulkan:");
|
|
println!(" loader instance version: {}", ver(instance_version));
|
|
|
|
let app_info = vk::ApplicationInfo::default().api_version(instance_version);
|
|
let create = vk::InstanceCreateInfo::default().application_info(&app_info);
|
|
let instance = match unsafe { entry.create_instance(&create, None) } {
|
|
Ok(i) => i,
|
|
Err(e) => {
|
|
println!(" create_instance failed -- {e}");
|
|
return;
|
|
}
|
|
};
|
|
|
|
let devices = unsafe { instance.enumerate_physical_devices() }.unwrap_or_default();
|
|
for phd in devices {
|
|
let props = unsafe { instance.get_physical_device_properties(phd) };
|
|
let name = unsafe { CStr::from_ptr(props.device_name.as_ptr()) };
|
|
println!(" device: {}", name.to_string_lossy());
|
|
println!(" device api version: {}", ver(props.api_version));
|
|
|
|
let exts =
|
|
unsafe { instance.enumerate_device_extension_properties(phd) }.unwrap_or_default();
|
|
let has_ext = exts.iter().any(|e| {
|
|
(unsafe { CStr::from_ptr(e.extension_name.as_ptr()) }) == c"VK_EXT_descriptor_indexing"
|
|
});
|
|
println!(" VK_EXT_descriptor_indexing advertised: {has_ext}");
|
|
println!(" device extensions: {}", exts.len());
|
|
|
|
let mut indexing = vk::PhysicalDeviceDescriptorIndexingFeatures::default();
|
|
let mut features2 = vk::PhysicalDeviceFeatures2::default().push_next(&mut indexing);
|
|
unsafe { instance.get_physical_device_features2(phd, &mut features2) };
|
|
|
|
for (name, v) in [
|
|
(
|
|
"shaderSampledImageArrayNonUniformIndexing",
|
|
indexing.shader_sampled_image_array_non_uniform_indexing,
|
|
),
|
|
(
|
|
"descriptorBindingSampledImageUpdateAfterBind",
|
|
indexing.descriptor_binding_sampled_image_update_after_bind,
|
|
),
|
|
(
|
|
"shaderStorageImageArrayNonUniformIndexing",
|
|
indexing.shader_storage_image_array_non_uniform_indexing,
|
|
),
|
|
(
|
|
"descriptorBindingStorageImageUpdateAfterBind",
|
|
indexing.descriptor_binding_storage_image_update_after_bind,
|
|
),
|
|
(
|
|
"shaderStorageBufferArrayNonUniformIndexing",
|
|
indexing.shader_storage_buffer_array_non_uniform_indexing,
|
|
),
|
|
(
|
|
"descriptorBindingStorageBufferUpdateAfterBind",
|
|
indexing.descriptor_binding_storage_buffer_update_after_bind,
|
|
),
|
|
(
|
|
"descriptorBindingPartiallyBound",
|
|
indexing.descriptor_binding_partially_bound,
|
|
),
|
|
] {
|
|
println!(" {name:48} {}", if v != 0 { "yes" } else { "NO" });
|
|
}
|
|
}
|
|
|
|
unsafe { instance.destroy_instance(None) };
|
|
}
|
|
|
|
fn ver(v: u32) -> String {
|
|
format!(
|
|
"{}.{}.{}",
|
|
vk::api_version_major(v),
|
|
vk::api_version_minor(v),
|
|
vk::api_version_patch(v)
|
|
)
|
|
}
|