mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-21 15:00:57 +01:00
* surface.acquire_texture: pass Option<Duration> for timeout A std::time::Duration allows for timeouts to be specified more clearly in Rust using whatever units are convenient for the caller, and an Option also makes it clearer in case no timeout is wanted, as opposed to passing a bitwise !0 as special timeout value. Notably there was an impedance mismatch with the Vulkan backend that takes a 64bit timeout in nanoseconds and uses u64::MAX to indicate no timeout and the backend was not mapping a given u32::MAX into a u64::MAX * surface.acquire_texture: ignore timeout for Android < 11 Prior to Android 11 then Android's vkAcquireNextImageKHR implementation was non-conformant and didn't support timeouts and additionally would log a verbose warning if a timeout was requested. For reference this version of AcquireNextImageKHR doesn't support timeouts: https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-10.0.0_r13/vulkan/libvulkan/swapchain.cpp#1426 and this version does: https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-11.0.0_r45/vulkan/libvulkan/swapchain.cpp#1438 (i.e. timeout support was added in Android 11) This patch adds a dependency on the `android-properties` crate that provides a simple wrapper for the `__system_property_set` syscall so that the platform version can be read via the `ro.build.version.sdk` property and then for versions < 30 (corresponds to Android 11) any timeout given to `acquire_texture` will be ignored (and `u64::MAX` will be passed to Vulkan)
818 lines
29 KiB
Rust
818 lines
29 KiB
Rust
use std::{
|
|
ffi::{c_void, CStr, CString},
|
|
slice,
|
|
sync::Arc,
|
|
thread,
|
|
};
|
|
|
|
use ash::{
|
|
extensions::{ext, khr},
|
|
vk,
|
|
};
|
|
|
|
use super::conv;
|
|
|
|
unsafe extern "system" fn debug_utils_messenger_callback(
|
|
message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
|
|
message_type: vk::DebugUtilsMessageTypeFlagsEXT,
|
|
callback_data_ptr: *const vk::DebugUtilsMessengerCallbackDataEXT,
|
|
_user_data: *mut c_void,
|
|
) -> vk::Bool32 {
|
|
use std::borrow::Cow;
|
|
if thread::panicking() {
|
|
return vk::FALSE;
|
|
}
|
|
|
|
let level = match message_severity {
|
|
vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE => log::Level::Debug,
|
|
vk::DebugUtilsMessageSeverityFlagsEXT::INFO => log::Level::Info,
|
|
vk::DebugUtilsMessageSeverityFlagsEXT::WARNING => log::Level::Warn,
|
|
vk::DebugUtilsMessageSeverityFlagsEXT::ERROR => log::Level::Error,
|
|
_ => log::Level::Warn,
|
|
};
|
|
|
|
let cd = &*callback_data_ptr;
|
|
|
|
let message_id_name = if cd.p_message_id_name.is_null() {
|
|
Cow::from("")
|
|
} else {
|
|
CStr::from_ptr(cd.p_message_id_name).to_string_lossy()
|
|
};
|
|
let message = if cd.p_message.is_null() {
|
|
Cow::from("")
|
|
} else {
|
|
CStr::from_ptr(cd.p_message).to_string_lossy()
|
|
};
|
|
|
|
let _ = std::panic::catch_unwind(|| {
|
|
log::log!(
|
|
level,
|
|
"{:?} [{} (0x{:x})]\n\t{}",
|
|
message_type,
|
|
message_id_name,
|
|
cd.message_id_number,
|
|
message,
|
|
);
|
|
});
|
|
|
|
if cd.queue_label_count != 0 {
|
|
let labels = slice::from_raw_parts(cd.p_queue_labels, cd.queue_label_count as usize);
|
|
let names = labels
|
|
.iter()
|
|
.flat_map(|dul_obj| {
|
|
dul_obj
|
|
.p_label_name
|
|
.as_ref()
|
|
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let _ = std::panic::catch_unwind(|| {
|
|
log::log!(level, "\tqueues: {}", names.join(", "));
|
|
});
|
|
}
|
|
|
|
if cd.cmd_buf_label_count != 0 {
|
|
let labels = slice::from_raw_parts(cd.p_cmd_buf_labels, cd.cmd_buf_label_count as usize);
|
|
let names = labels
|
|
.iter()
|
|
.flat_map(|dul_obj| {
|
|
dul_obj
|
|
.p_label_name
|
|
.as_ref()
|
|
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let _ = std::panic::catch_unwind(|| {
|
|
log::log!(level, "\tcommand buffers: {}", names.join(", "));
|
|
});
|
|
}
|
|
|
|
if cd.object_count != 0 {
|
|
let labels = slice::from_raw_parts(cd.p_objects, cd.object_count as usize);
|
|
//TODO: use color fields of `vk::DebugUtilsLabelExt`?
|
|
let names = labels
|
|
.iter()
|
|
.map(|obj_info| {
|
|
let name = obj_info
|
|
.p_object_name
|
|
.as_ref()
|
|
.map(|name| CStr::from_ptr(name).to_string_lossy())
|
|
.unwrap_or(Cow::Borrowed("?"));
|
|
|
|
format!(
|
|
"(type: {:?}, hndl: 0x{:x}, name: {})",
|
|
obj_info.object_type, obj_info.object_handle, name
|
|
)
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let _ = std::panic::catch_unwind(|| {
|
|
log::log!(level, "\tobjects: {}", names.join(", "));
|
|
});
|
|
}
|
|
|
|
if cfg!(debug_assertions) && level == log::Level::Error {
|
|
// Set canary and continue
|
|
crate::VALIDATION_CANARY.set();
|
|
}
|
|
|
|
vk::FALSE
|
|
}
|
|
|
|
impl super::Swapchain {
|
|
unsafe fn release_resources(self, device: &ash::Device) -> Self {
|
|
profiling::scope!("Swapchain::release_resources");
|
|
{
|
|
profiling::scope!("vkDeviceWaitIdle");
|
|
let _ = device.device_wait_idle();
|
|
};
|
|
device.destroy_fence(self.fence, None);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl super::Instance {
|
|
pub fn entry(&self) -> &ash::Entry {
|
|
&self.shared.entry
|
|
}
|
|
|
|
pub fn raw_instance(&self) -> &ash::Instance {
|
|
&self.shared.raw
|
|
}
|
|
|
|
pub fn driver_api_version(&self) -> u32 {
|
|
self.shared.driver_api_version
|
|
}
|
|
|
|
pub fn extensions(&self) -> &[&'static CStr] {
|
|
&self.extensions[..]
|
|
}
|
|
|
|
pub fn required_extensions(
|
|
entry: &ash::Entry,
|
|
flags: crate::InstanceFlags,
|
|
) -> Result<Vec<&'static CStr>, crate::InstanceError> {
|
|
let instance_extensions = entry
|
|
.enumerate_instance_extension_properties(None)
|
|
.map_err(|e| {
|
|
log::info!("enumerate_instance_extension_properties: {:?}", e);
|
|
crate::InstanceError
|
|
})?;
|
|
|
|
// Check our extensions against the available extensions
|
|
let mut extensions: Vec<&'static CStr> = Vec::new();
|
|
extensions.push(khr::Surface::name());
|
|
|
|
// Platform-specific WSI extensions
|
|
if cfg!(all(
|
|
unix,
|
|
not(target_os = "android"),
|
|
not(target_os = "macos")
|
|
)) {
|
|
extensions.push(khr::XlibSurface::name());
|
|
extensions.push(khr::XcbSurface::name());
|
|
extensions.push(khr::WaylandSurface::name());
|
|
}
|
|
if cfg!(target_os = "android") {
|
|
extensions.push(khr::AndroidSurface::name());
|
|
}
|
|
if cfg!(target_os = "windows") {
|
|
extensions.push(khr::Win32Surface::name());
|
|
}
|
|
if cfg!(target_os = "macos") {
|
|
extensions.push(ext::MetalSurface::name());
|
|
}
|
|
|
|
if flags.contains(crate::InstanceFlags::DEBUG) {
|
|
extensions.push(ext::DebugUtils::name());
|
|
}
|
|
|
|
extensions.push(vk::KhrGetPhysicalDeviceProperties2Fn::name());
|
|
|
|
// Provid wide color gamut
|
|
extensions.push(vk::ExtSwapchainColorspaceFn::name());
|
|
|
|
// Only keep available extensions.
|
|
extensions.retain(|&ext| {
|
|
if instance_extensions
|
|
.iter()
|
|
.any(|inst_ext| unsafe { CStr::from_ptr(inst_ext.extension_name.as_ptr()) == ext })
|
|
{
|
|
true
|
|
} else {
|
|
log::info!("Unable to find extension: {}", ext.to_string_lossy());
|
|
false
|
|
}
|
|
});
|
|
Ok(extensions)
|
|
}
|
|
|
|
/// # Safety
|
|
///
|
|
/// - `raw_instance` must be created from `entry`
|
|
/// - `raw_instance` must be created respecting `driver_api_version`, `extensions` and `flags`
|
|
/// - `extensions` must be a superset of `required_extensions()` and must be created from the
|
|
/// same entry, driver_api_version and flags.
|
|
/// - `android_sdk_version` is ignored and can be `0` for all platforms besides Android
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub unsafe fn from_raw(
|
|
entry: ash::Entry,
|
|
raw_instance: ash::Instance,
|
|
driver_api_version: u32,
|
|
android_sdk_version: u32,
|
|
extensions: Vec<&'static CStr>,
|
|
flags: crate::InstanceFlags,
|
|
has_nv_optimus: bool,
|
|
drop_guard: Option<super::DropGuard>,
|
|
) -> Result<Self, crate::InstanceError> {
|
|
log::info!("Instance version: 0x{:x}", driver_api_version);
|
|
|
|
let debug_utils = if extensions.contains(&ext::DebugUtils::name()) {
|
|
log::info!("Enabling debug utils");
|
|
let extension = ext::DebugUtils::new(&entry, &raw_instance);
|
|
// having ERROR unconditionally because Vk doesn't like empty flags
|
|
let mut severity = vk::DebugUtilsMessageSeverityFlagsEXT::ERROR;
|
|
if log::max_level() >= log::LevelFilter::Debug {
|
|
severity |= vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE;
|
|
}
|
|
if log::max_level() >= log::LevelFilter::Info {
|
|
severity |= vk::DebugUtilsMessageSeverityFlagsEXT::INFO;
|
|
}
|
|
if log::max_level() >= log::LevelFilter::Warn {
|
|
severity |= vk::DebugUtilsMessageSeverityFlagsEXT::WARNING;
|
|
}
|
|
let vk_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
|
|
.flags(vk::DebugUtilsMessengerCreateFlagsEXT::empty())
|
|
.message_severity(severity)
|
|
.message_type(
|
|
vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
|
|
| vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
|
|
| vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
|
|
)
|
|
.pfn_user_callback(Some(debug_utils_messenger_callback));
|
|
let messenger = extension
|
|
.create_debug_utils_messenger(&vk_info, None)
|
|
.unwrap();
|
|
Some(super::DebugUtils {
|
|
extension,
|
|
messenger,
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// We can't use any of Vulkan-1.1+ abilities on Vk 1.0 instance,
|
|
// so disabling this query helps.
|
|
let get_physical_device_properties = if driver_api_version >= vk::API_VERSION_1_1
|
|
&& extensions.contains(&khr::GetPhysicalDeviceProperties2::name())
|
|
{
|
|
log::info!("Enabling device properties2");
|
|
Some(khr::GetPhysicalDeviceProperties2::new(
|
|
&entry,
|
|
&raw_instance,
|
|
))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Ok(Self {
|
|
shared: Arc::new(super::InstanceShared {
|
|
raw: raw_instance,
|
|
drop_guard,
|
|
flags,
|
|
debug_utils,
|
|
get_physical_device_properties,
|
|
entry,
|
|
has_nv_optimus,
|
|
driver_api_version,
|
|
android_sdk_version,
|
|
}),
|
|
extensions,
|
|
})
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_surface_from_xlib(
|
|
&self,
|
|
dpy: *mut vk::Display,
|
|
window: vk::Window,
|
|
) -> super::Surface {
|
|
if !self.extensions.contains(&khr::XlibSurface::name()) {
|
|
panic!("Vulkan driver does not support VK_KHR_XLIB_SURFACE");
|
|
}
|
|
|
|
let surface = {
|
|
let xlib_loader = khr::XlibSurface::new(&self.shared.entry, &self.shared.raw);
|
|
let info = vk::XlibSurfaceCreateInfoKHR::builder()
|
|
.flags(vk::XlibSurfaceCreateFlagsKHR::empty())
|
|
.window(window)
|
|
.dpy(dpy);
|
|
|
|
unsafe { xlib_loader.create_xlib_surface(&info, None) }
|
|
.expect("XlibSurface::create_xlib_surface() failed")
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_surface_from_xcb(
|
|
&self,
|
|
connection: *mut vk::xcb_connection_t,
|
|
window: vk::xcb_window_t,
|
|
) -> super::Surface {
|
|
if !self.extensions.contains(&khr::XcbSurface::name()) {
|
|
panic!("Vulkan driver does not support VK_KHR_XCB_SURFACE");
|
|
}
|
|
|
|
let surface = {
|
|
let xcb_loader = khr::XcbSurface::new(&self.shared.entry, &self.shared.raw);
|
|
let info = vk::XcbSurfaceCreateInfoKHR::builder()
|
|
.flags(vk::XcbSurfaceCreateFlagsKHR::empty())
|
|
.window(window)
|
|
.connection(connection);
|
|
|
|
unsafe { xcb_loader.create_xcb_surface(&info, None) }
|
|
.expect("XcbSurface::create_xcb_surface() failed")
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_surface_from_wayland(
|
|
&self,
|
|
display: *mut c_void,
|
|
surface: *mut c_void,
|
|
) -> super::Surface {
|
|
if !self.extensions.contains(&khr::WaylandSurface::name()) {
|
|
panic!("Vulkan driver does not support VK_KHR_WAYLAND_SURFACE");
|
|
}
|
|
|
|
let surface = {
|
|
let w_loader = khr::WaylandSurface::new(&self.shared.entry, &self.shared.raw);
|
|
let info = vk::WaylandSurfaceCreateInfoKHR::builder()
|
|
.flags(vk::WaylandSurfaceCreateFlagsKHR::empty())
|
|
.display(display)
|
|
.surface(surface);
|
|
|
|
unsafe { w_loader.create_wayland_surface(&info, None) }.expect("WaylandSurface failed")
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_surface_android(&self, window: *const c_void) -> super::Surface {
|
|
let surface = {
|
|
let a_loader = khr::AndroidSurface::new(&self.shared.entry, &self.shared.raw);
|
|
let info = vk::AndroidSurfaceCreateInfoKHR::builder()
|
|
.flags(vk::AndroidSurfaceCreateFlagsKHR::empty())
|
|
.window(window as *mut _);
|
|
|
|
unsafe { a_loader.create_android_surface(&info, None) }.expect("AndroidSurface failed")
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_surface_from_hwnd(
|
|
&self,
|
|
hinstance: *mut c_void,
|
|
hwnd: *mut c_void,
|
|
) -> super::Surface {
|
|
if !self.extensions.contains(&khr::Win32Surface::name()) {
|
|
panic!("Vulkan driver does not support VK_KHR_WIN32_SURFACE");
|
|
}
|
|
|
|
let surface = {
|
|
let info = vk::Win32SurfaceCreateInfoKHR::builder()
|
|
.flags(vk::Win32SurfaceCreateFlagsKHR::empty())
|
|
.hinstance(hinstance)
|
|
.hwnd(hwnd);
|
|
let win32_loader = khr::Win32Surface::new(&self.shared.entry, &self.shared.raw);
|
|
unsafe {
|
|
win32_loader
|
|
.create_win32_surface(&info, None)
|
|
.expect("Unable to create Win32 surface")
|
|
}
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
|
fn create_surface_from_view(&self, view: *mut c_void) -> super::Surface {
|
|
use core_graphics_types::{base::CGFloat, geometry::CGRect};
|
|
use objc::{
|
|
class, msg_send,
|
|
runtime::{Object, BOOL, YES},
|
|
sel, sel_impl,
|
|
};
|
|
|
|
let layer = unsafe {
|
|
let view = view as *mut Object;
|
|
let existing: *mut Object = msg_send![view, layer];
|
|
let class = class!(CAMetalLayer);
|
|
|
|
let use_current: BOOL = msg_send![existing, isKindOfClass: class];
|
|
if use_current == YES {
|
|
existing
|
|
} else {
|
|
let new_layer: *mut Object = msg_send![class, new];
|
|
let frame: CGRect = msg_send![existing, bounds];
|
|
let () = msg_send![new_layer, setFrame: frame];
|
|
|
|
let scale_factor: CGFloat = if cfg!(target_os = "ios") {
|
|
let () = msg_send![existing, addSublayer: new_layer];
|
|
// On iOS, `create_surface_from_view` may be called before the application initialization is complete,
|
|
// `msg_send![view, window]` and `msg_send![window, screen]` will get null.
|
|
let screen: *mut Object = msg_send![class!(UIScreen), mainScreen];
|
|
msg_send![screen, nativeScale]
|
|
} else {
|
|
let () = msg_send![view, setLayer: new_layer];
|
|
let () = msg_send![view, setWantsLayer: YES];
|
|
let window: *mut Object = msg_send![view, window];
|
|
if !window.is_null() {
|
|
msg_send![window, backingScaleFactor]
|
|
} else {
|
|
1.0
|
|
}
|
|
};
|
|
let () = msg_send![new_layer, setContentsScale: scale_factor];
|
|
|
|
new_layer
|
|
}
|
|
};
|
|
|
|
let surface = {
|
|
let metal_loader = ext::MetalSurface::new(&self.shared.entry, &self.shared.raw);
|
|
let vk_info = vk::MetalSurfaceCreateInfoEXT::builder()
|
|
.flags(vk::MetalSurfaceCreateFlagsEXT::empty())
|
|
.layer(layer as *mut _)
|
|
.build();
|
|
|
|
unsafe { metal_loader.create_metal_surface(&vk_info, None).unwrap() }
|
|
};
|
|
|
|
self.create_surface_from_vk_surface_khr(surface)
|
|
}
|
|
|
|
fn create_surface_from_vk_surface_khr(&self, surface: vk::SurfaceKHR) -> super::Surface {
|
|
let functor = khr::Surface::new(&self.shared.entry, &self.shared.raw);
|
|
super::Surface {
|
|
raw: surface,
|
|
functor,
|
|
instance: Arc::clone(&self.shared),
|
|
swapchain: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for super::InstanceShared {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
if let Some(du) = self.debug_utils.take() {
|
|
du.extension
|
|
.destroy_debug_utils_messenger(du.messenger, None);
|
|
}
|
|
if let Some(_drop_guard) = self.drop_guard.take() {
|
|
self.raw.destroy_instance(None);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl crate::Instance<super::Api> for super::Instance {
|
|
unsafe fn init(desc: &crate::InstanceDescriptor) -> Result<Self, crate::InstanceError> {
|
|
let entry = match ash::Entry::load() {
|
|
Ok(entry) => entry,
|
|
Err(err) => {
|
|
log::info!("Missing Vulkan entry points: {:?}", err);
|
|
return Err(crate::InstanceError);
|
|
}
|
|
};
|
|
let driver_api_version = match entry.try_enumerate_instance_version() {
|
|
// Vulkan 1.1+
|
|
Ok(Some(version)) => version,
|
|
Ok(None) => vk::API_VERSION_1_0,
|
|
Err(err) => {
|
|
log::warn!("try_enumerate_instance_version: {:?}", err);
|
|
return Err(crate::InstanceError);
|
|
}
|
|
};
|
|
|
|
let app_name = CString::new(desc.name).unwrap();
|
|
let app_info = vk::ApplicationInfo::builder()
|
|
.application_name(app_name.as_c_str())
|
|
.application_version(1)
|
|
.engine_name(CStr::from_bytes_with_nul(b"wgpu-hal\0").unwrap())
|
|
.engine_version(2)
|
|
.api_version(
|
|
// Vulkan 1.0 doesn't like anything but 1.0 passed in here...
|
|
if driver_api_version < vk::API_VERSION_1_1 {
|
|
vk::API_VERSION_1_0
|
|
} else {
|
|
// This is the max Vulkan API version supported by `wgpu-hal`.
|
|
//
|
|
// If we want to increment this, there are some things that must be done first:
|
|
// - Audit the behavioral differences between the previous and new API versions.
|
|
// - Audit all extensions used by this backend:
|
|
// - If any were promoted in the new API version and the behavior has changed, we must handle the new behavior in addition to the old behavior.
|
|
// - If any were obsoleted in the new API version, we must implement a fallback for the new API version
|
|
// - If any are non-KHR-vendored, we must ensure the new behavior is still correct (since backwards-compatibility is not guaranteed).
|
|
vk::HEADER_VERSION_COMPLETE
|
|
},
|
|
);
|
|
|
|
let extensions = Self::required_extensions(&entry, desc.flags)?;
|
|
|
|
let instance_layers = entry.enumerate_instance_layer_properties().map_err(|e| {
|
|
log::info!("enumerate_instance_layer_properties: {:?}", e);
|
|
crate::InstanceError
|
|
})?;
|
|
|
|
let nv_optimus_layer = CStr::from_bytes_with_nul(b"VK_LAYER_NV_optimus\0").unwrap();
|
|
let has_nv_optimus = instance_layers
|
|
.iter()
|
|
.any(|inst_layer| CStr::from_ptr(inst_layer.layer_name.as_ptr()) == nv_optimus_layer);
|
|
|
|
// Check requested layers against the available layers
|
|
let layers = {
|
|
let mut layers: Vec<&'static CStr> = Vec::new();
|
|
if desc.flags.contains(crate::InstanceFlags::VALIDATION) {
|
|
layers.push(CStr::from_bytes_with_nul(b"VK_LAYER_KHRONOS_validation\0").unwrap());
|
|
}
|
|
|
|
// Only keep available layers.
|
|
layers.retain(|&layer| {
|
|
if instance_layers
|
|
.iter()
|
|
.any(|inst_layer| CStr::from_ptr(inst_layer.layer_name.as_ptr()) == layer)
|
|
{
|
|
true
|
|
} else {
|
|
log::warn!("Unable to find layer: {}", layer.to_string_lossy());
|
|
false
|
|
}
|
|
});
|
|
layers
|
|
};
|
|
|
|
#[cfg(target_os = "android")]
|
|
let android_sdk_version = {
|
|
// See: https://developer.android.com/reference/android/os/Build.VERSION_CODES
|
|
let mut prop = android_properties::getprop("ro.build.version.sdk");
|
|
if let Some(val) = prop.value() {
|
|
match val.parse::<u32>() {
|
|
Ok(sdk_ver) => sdk_ver,
|
|
Err(err) => {
|
|
log::error!(
|
|
"Couldn't parse Android's ro.build.version.sdk system property ({val}): {err}"
|
|
);
|
|
0
|
|
}
|
|
}
|
|
} else {
|
|
log::error!("Couldn't read Android's ro.build.version.sdk system property");
|
|
0
|
|
}
|
|
};
|
|
#[cfg(not(target_os = "android"))]
|
|
let android_sdk_version = 0;
|
|
|
|
let vk_instance = {
|
|
let str_pointers = layers
|
|
.iter()
|
|
.chain(extensions.iter())
|
|
.map(|&s| {
|
|
// Safe because `layers` and `extensions` entries have static lifetime.
|
|
s.as_ptr()
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let create_info = vk::InstanceCreateInfo::builder()
|
|
.flags(vk::InstanceCreateFlags::empty())
|
|
.application_info(&app_info)
|
|
.enabled_layer_names(&str_pointers[..layers.len()])
|
|
.enabled_extension_names(&str_pointers[layers.len()..]);
|
|
|
|
entry.create_instance(&create_info, None).map_err(|e| {
|
|
log::warn!("create_instance: {:?}", e);
|
|
crate::InstanceError
|
|
})?
|
|
};
|
|
|
|
Self::from_raw(
|
|
entry,
|
|
vk_instance,
|
|
driver_api_version,
|
|
android_sdk_version,
|
|
extensions,
|
|
desc.flags,
|
|
has_nv_optimus,
|
|
Some(Box::new(())), // `Some` signals that wgpu-hal is in charge of destroying vk_instance
|
|
)
|
|
}
|
|
|
|
unsafe fn create_surface(
|
|
&self,
|
|
has_handle: &impl raw_window_handle::HasRawWindowHandle,
|
|
) -> Result<super::Surface, crate::InstanceError> {
|
|
use raw_window_handle::RawWindowHandle;
|
|
|
|
match has_handle.raw_window_handle() {
|
|
RawWindowHandle::Wayland(handle)
|
|
if self.extensions.contains(&khr::WaylandSurface::name()) =>
|
|
{
|
|
Ok(self.create_surface_from_wayland(handle.display, handle.surface))
|
|
}
|
|
RawWindowHandle::Xlib(handle)
|
|
if self.extensions.contains(&khr::XlibSurface::name()) =>
|
|
{
|
|
Ok(self.create_surface_from_xlib(handle.display as *mut _, handle.window))
|
|
}
|
|
RawWindowHandle::Xcb(handle) if self.extensions.contains(&khr::XcbSurface::name()) => {
|
|
Ok(self.create_surface_from_xcb(handle.connection, handle.window))
|
|
}
|
|
RawWindowHandle::AndroidNdk(handle) => {
|
|
Ok(self.create_surface_android(handle.a_native_window))
|
|
}
|
|
#[cfg(windows)]
|
|
RawWindowHandle::Win32(handle) => {
|
|
use winapi::um::libloaderapi::GetModuleHandleW;
|
|
|
|
let hinstance = GetModuleHandleW(std::ptr::null());
|
|
Ok(self.create_surface_from_hwnd(hinstance as *mut _, handle.hwnd))
|
|
}
|
|
#[cfg(target_os = "macos")]
|
|
RawWindowHandle::AppKit(handle)
|
|
if self.extensions.contains(&ext::MetalSurface::name()) =>
|
|
{
|
|
Ok(self.create_surface_from_view(handle.ns_view))
|
|
}
|
|
#[cfg(target_os = "ios")]
|
|
RawWindowHandle::UiKit(handle)
|
|
if self.extensions.contains(&ext::MetalSurface::name()) =>
|
|
{
|
|
Ok(self.create_surface_from_view(handle.ui_view))
|
|
}
|
|
_ => Err(crate::InstanceError),
|
|
}
|
|
}
|
|
|
|
unsafe fn destroy_surface(&self, surface: super::Surface) {
|
|
surface.functor.destroy_surface(surface.raw, None);
|
|
}
|
|
|
|
unsafe fn enumerate_adapters(&self) -> Vec<crate::ExposedAdapter<super::Api>> {
|
|
use crate::auxil::db;
|
|
|
|
let raw_devices = match self.shared.raw.enumerate_physical_devices() {
|
|
Ok(devices) => devices,
|
|
Err(err) => {
|
|
log::error!("enumerate_adapters: {}", err);
|
|
Vec::new()
|
|
}
|
|
};
|
|
|
|
let mut exposed_adapters = raw_devices
|
|
.into_iter()
|
|
.flat_map(|device| self.expose_adapter(device))
|
|
.collect::<Vec<_>>();
|
|
|
|
// Detect if it's an Intel + NVidia configuration with Optimus
|
|
let has_nvidia_dgpu = exposed_adapters.iter().any(|exposed| {
|
|
exposed.info.device_type == wgt::DeviceType::DiscreteGpu
|
|
&& exposed.info.vendor == db::nvidia::VENDOR as usize
|
|
});
|
|
if cfg!(target_os = "linux") && has_nvidia_dgpu && self.shared.has_nv_optimus {
|
|
for exposed in exposed_adapters.iter_mut() {
|
|
if exposed.info.device_type == wgt::DeviceType::IntegratedGpu
|
|
&& exposed.info.vendor == db::intel::VENDOR as usize
|
|
{
|
|
// See https://gitlab.freedesktop.org/mesa/mesa/-/issues/4688
|
|
log::warn!(
|
|
"Disabling presentation on '{}' (id {:?}) because of NV Optimus (on Linux)",
|
|
exposed.info.name,
|
|
exposed.adapter.raw
|
|
);
|
|
exposed.adapter.private_caps.can_present = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
exposed_adapters
|
|
}
|
|
}
|
|
|
|
impl crate::Surface<super::Api> for super::Surface {
|
|
unsafe fn configure(
|
|
&mut self,
|
|
device: &super::Device,
|
|
config: &crate::SurfaceConfiguration,
|
|
) -> Result<(), crate::SurfaceError> {
|
|
let old = self
|
|
.swapchain
|
|
.take()
|
|
.map(|sc| sc.release_resources(&device.shared.raw));
|
|
|
|
let swapchain = device.create_swapchain(self, config, old)?;
|
|
self.swapchain = Some(swapchain);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn unconfigure(&mut self, device: &super::Device) {
|
|
if let Some(sc) = self.swapchain.take() {
|
|
let swapchain = sc.release_resources(&device.shared.raw);
|
|
swapchain.functor.destroy_swapchain(swapchain.raw, None);
|
|
}
|
|
}
|
|
|
|
unsafe fn acquire_texture(
|
|
&mut self,
|
|
timeout: Option<std::time::Duration>,
|
|
) -> Result<Option<crate::AcquiredSurfaceTexture<super::Api>>, crate::SurfaceError> {
|
|
let sc = self.swapchain.as_mut().unwrap();
|
|
|
|
let mut timeout_ns = match timeout {
|
|
Some(duration) => duration.as_nanos() as u64,
|
|
None => u64::MAX,
|
|
};
|
|
|
|
// AcquireNextImageKHR on Android (prior to Android 11) doesn't support timeouts
|
|
// and will also log verbose warnings if tying to use a timeout.
|
|
//
|
|
// Android 10 implementation for reference:
|
|
// https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-10.0.0_r13/vulkan/libvulkan/swapchain.cpp#1426
|
|
// Android 11 implementation for reference:
|
|
// https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-11.0.0_r45/vulkan/libvulkan/swapchain.cpp#1438
|
|
//
|
|
// Android 11 corresponds to an SDK_INT/ro.build.version.sdk of 30
|
|
if cfg!(target_os = "android") && self.instance.android_sdk_version < 30 {
|
|
timeout_ns = u64::MAX;
|
|
}
|
|
|
|
// will block if no image is available
|
|
let (index, suboptimal) =
|
|
match sc
|
|
.functor
|
|
.acquire_next_image(sc.raw, timeout_ns, vk::Semaphore::null(), sc.fence)
|
|
{
|
|
Ok(pair) => pair,
|
|
Err(error) => {
|
|
return match error {
|
|
vk::Result::TIMEOUT => Ok(None),
|
|
vk::Result::NOT_READY | vk::Result::ERROR_OUT_OF_DATE_KHR => {
|
|
Err(crate::SurfaceError::Outdated)
|
|
}
|
|
vk::Result::ERROR_SURFACE_LOST_KHR => Err(crate::SurfaceError::Lost),
|
|
other => Err(crate::DeviceError::from(other).into()),
|
|
}
|
|
}
|
|
};
|
|
|
|
// special case for Intel Vulkan returning bizzare values (ugh)
|
|
if sc.device.vendor_id == crate::auxil::db::intel::VENDOR && index > 0x100 {
|
|
return Err(crate::SurfaceError::Outdated);
|
|
}
|
|
|
|
let fences = &[sc.fence];
|
|
|
|
sc.device
|
|
.raw
|
|
.wait_for_fences(fences, true, !0)
|
|
.map_err(crate::DeviceError::from)?;
|
|
sc.device
|
|
.raw
|
|
.reset_fences(fences)
|
|
.map_err(crate::DeviceError::from)?;
|
|
|
|
let texture = super::SurfaceTexture {
|
|
index,
|
|
texture: super::Texture {
|
|
raw: sc.images[index as usize],
|
|
drop_guard: None,
|
|
block: None,
|
|
usage: sc.config.usage,
|
|
aspects: crate::FormatAspects::COLOR,
|
|
format_info: sc.config.format.describe(),
|
|
raw_flags: vk::ImageCreateFlags::empty(),
|
|
copy_size: conv::map_extent_to_copy_size(
|
|
&sc.config.extent,
|
|
wgt::TextureDimension::D2,
|
|
),
|
|
},
|
|
};
|
|
Ok(Some(crate::AcquiredSurfaceTexture {
|
|
texture,
|
|
suboptimal,
|
|
}))
|
|
}
|
|
|
|
unsafe fn discard_texture(&mut self, _texture: super::SurfaceTexture) {}
|
|
}
|