archive-gh-me/wgpu
1
0
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2025-12-08 21:26:17 +00:00
Code Issues Projects Releases Wiki Activity

[egl] get rid of unwrap where possible (#8024)

Browse Source 
Co-authored-by: Andreas Reich <r_andreas2@web.de>
This commit is contained in:
Lucas Abel 2025-08-28 23:59:54 +02:00 committed by GitHub
parent 0aacfeadff
commit cd14b194a4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 155 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -133,6 +133,10 @@ By @cwfitzgerald in [#8162](https://github.com/gfx-rs/wgpu/pull/8162).
- Fixed a bug where access to matrices with 2 rows would not work in some cases. By @andyleiserson in [#7438](https://github.com/gfx-rs/wgpu/pull/7438). - Fixed a bug where access to matrices with 2 rows would not work in some cases. By @andyleiserson in [#7438](https://github.com/gfx-rs/wgpu/pull/7438).
##### EGL
- Fixed unwrap failed in context creation for some Android devices. By @uael in [#8024](https://github.com/gfx-rs/wgpu/pull/8024).
#### naga #### naga
- [wgsl-in] Allow a trailing comma in `@blend_src(…)` attributes. By @ErichDonGubler in [#8137](https://github.com/gfx-rs/wgpu/pull/8137). - [wgsl-in] Allow a trailing comma in `@blend_src(…)` attributes. By @ErichDonGubler in [#8137](https://github.com/gfx-rs/wgpu/pull/8137).

260
wgpu-hal/src/gles/egl.rs
View File

@ -136,8 +136,13 @@ impl Drop for DisplayOwner {
fn drop(&mut self) { fn drop(&mut self) {
match self.display { match self.display {
DisplayRef::X11(ptr) => unsafe { DisplayRef::X11(ptr) => unsafe {
let func: libloading::Symbol<XCloseDisplayFun> = let Ok(func): Result<libloading::Symbol<XCloseDisplayFun>, _> = self
self.library.get(c"XCloseDisplay".to_bytes()).unwrap(); .library
.get(c"XCloseDisplay".to_bytes())
.inspect_err(|err| log::error!("Failed to load XCloseDisplay: {err:?}"))
else {
return;
};
func(ptr.as_ptr()); func(ptr.as_ptr());
}, },
DisplayRef::Wayland => {} DisplayRef::Wayland => {}
@ -149,8 +154,10 @@ fn open_x_display() -> Option<DisplayOwner> {
log::debug!("Loading X11 library to get the current display"); log::debug!("Loading X11 library to get the current display");
unsafe { unsafe {
let library = find_library(&["libX11.so.6", "libX11.so"])?; let library = find_library(&["libX11.so.6", "libX11.so"])?;
let func: libloading::Symbol<XOpenDisplayFun> = let func: libloading::Symbol<XOpenDisplayFun> = library
library.get(c"XOpenDisplay".to_bytes()).unwrap(); .get(c"XOpenDisplay".to_bytes())
.inspect_err(|err| log::error!("Failed to load XOpenDisplay: {err:?}"))
.ok()?;
let result = func(ptr::null()); let result = func(ptr::null());
ptr::NonNull::new(result).map(|ptr| DisplayOwner { ptr::NonNull::new(result).map(|ptr| DisplayOwner {
display: DisplayRef::X11(ptr), display: DisplayRef::X11(ptr),
@ -178,10 +185,12 @@ fn test_wayland_display() -> Option<DisplayOwner> {
let client_library = find_library(&["libwayland-client.so.0", "libwayland-client.so"])?; let client_library = find_library(&["libwayland-client.so.0", "libwayland-client.so"])?;
let wl_display_connect: libloading::Symbol<WlDisplayConnectFun> = client_library let wl_display_connect: libloading::Symbol<WlDisplayConnectFun> = client_library
.get(c"wl_display_connect".to_bytes()) .get(c"wl_display_connect".to_bytes())
.unwrap(); .inspect_err(|err| log::error!("Failed to load wl_display_connect: {err:?}"))
.ok()?;
let wl_display_disconnect: libloading::Symbol<WlDisplayDisconnectFun> = client_library let wl_display_disconnect: libloading::Symbol<WlDisplayDisconnectFun> = client_library
.get(c"wl_display_disconnect".to_bytes()) .get(c"wl_display_disconnect".to_bytes())
.unwrap(); .inspect_err(|err| log::error!("Failed to load wl_display_disconnect: {err:?}"))
.ok()?;
let display = ptr::NonNull::new(wl_display_connect(ptr::null()))?; let display = ptr::NonNull::new(wl_display_connect(ptr::null()))?;
wl_display_disconnect(display.as_ptr()); wl_display_disconnect(display.as_ptr());
find_library(&["libwayland-egl.so.1", "libwayland-egl.so"])? find_library(&["libwayland-egl.so.1", "libwayland-egl.so"])?
@ -394,9 +403,9 @@ impl<'a> core::ops::Deref for AdapterContextLock<'a> {
impl<'a> Drop for AdapterContextLock<'a> { impl<'a> Drop for AdapterContextLock<'a> {
fn drop(&mut self) { fn drop(&mut self) {
if let Some(egl) = self.egl.take() { if let Some(egl) = self.egl.take() {
egl.instance if let Err(err) = egl.instance.make_current(egl.display, None, None, None) {
.make_current(egl.display, None, None, None) log::error!("Failed to make EGL context current: {err:?}");
.unwrap(); }
} }
} }
} }
@ -501,6 +510,12 @@ fn terminate_display(
} }
} }
fn instance_err<E: core::error::Error + Send + Sync + 'static>(
message: impl Into<String>,
) -> impl FnOnce(E) -> crate::InstanceError {
move |e| crate::InstanceError::with_source(message.into(), e)
}
impl Inner { impl Inner {
fn create( fn create(
flags: wgt::InstanceFlags, flags: wgt::InstanceFlags,
@ -508,18 +523,14 @@ impl Inner {
display: khronos_egl::Display, display: khronos_egl::Display,
force_gles_minor_version: wgt::Gles3MinorVersion, force_gles_minor_version: wgt::Gles3MinorVersion,
) -> Result<Self, crate::InstanceError> { ) -> Result<Self, crate::InstanceError> {
let version = initialize_display(&egl, display).map_err(|e| { let version = initialize_display(&egl, display)
crate::InstanceError::with_source( .map_err(instance_err("failed to initialize EGL display connection"))?;
String::from("failed to initialize EGL display connection"),
e,
)
})?;
let vendor = egl let vendor = egl
.query_string(Some(display), khronos_egl::VENDOR) .query_string(Some(display), khronos_egl::VENDOR)
.unwrap(); .map_err(instance_err("failed to query EGL vendor"))?;
let display_extensions = egl let display_extensions = egl
.query_string(Some(display), khronos_egl::EXTENSIONS) .query_string(Some(display), khronos_egl::EXTENSIONS)
.unwrap() .map_err(instance_err("failed to query EGL display extensions"))?
.to_string_lossy(); .to_string_lossy();
log::debug!("Display vendor {vendor:?}, version {version:?}",); log::debug!("Display vendor {vendor:?}, version {version:?}",);
log::debug!( log::debug!(
@ -540,16 +551,19 @@ impl Inner {
if log::max_level() >= log::LevelFilter::Trace { if log::max_level() >= log::LevelFilter::Trace {
log::trace!("Configurations:"); log::trace!("Configurations:");
let config_count = egl.get_config_count(display).unwrap(); let config_count = egl
.get_config_count(display)
.map_err(instance_err("failed to get config count"))?;
let mut configurations = Vec::with_capacity(config_count); let mut configurations = Vec::with_capacity(config_count);
egl.get_configs(display, &mut configurations).unwrap(); egl.get_configs(display, &mut configurations)
.map_err(instance_err("failed to get configs"))?;
for &config in configurations.iter() { for &config in configurations.iter() {
log::trace!("\tCONFORMANT=0x{:X}, RENDERABLE=0x{:X}, NATIVE_RENDERABLE=0x{:X}, SURFACE_TYPE=0x{:X}, ALPHA_SIZE={}", log::trace!("\tCONFORMANT=0x{:X?}, RENDERABLE=0x{:X?}, NATIVE_RENDERABLE=0x{:X?}, SURFACE_TYPE=0x{:X?}, ALPHA_SIZE={:?}",
egl.get_config_attrib(display, config, khronos_egl::CONFORMANT).unwrap(), egl.get_config_attrib(display, config, khronos_egl::CONFORMANT),
egl.get_config_attrib(display, config, khronos_egl::RENDERABLE_TYPE).unwrap(), egl.get_config_attrib(display, config, khronos_egl::RENDERABLE_TYPE),
egl.get_config_attrib(display, config, khronos_egl::NATIVE_RENDERABLE).unwrap(), egl.get_config_attrib(display, config, khronos_egl::NATIVE_RENDERABLE),
egl.get_config_attrib(display, config, khronos_egl::SURFACE_TYPE).unwrap(), egl.get_config_attrib(display, config, khronos_egl::SURFACE_TYPE),
egl.get_config_attrib(display, config, khronos_egl::ALPHA_SIZE).unwrap(), egl.get_config_attrib(display, config, khronos_egl::ALPHA_SIZE),
); );
} }
} }
@ -559,7 +573,7 @@ impl Inner {
let supports_opengl = if version >= (1, 4) { let supports_opengl = if version >= (1, 4) {
let client_apis = egl let client_apis = egl
.query_string(Some(display), khronos_egl::CLIENT_APIS) .query_string(Some(display), khronos_egl::CLIENT_APIS)
.unwrap() .map_err(instance_err("failed to query EGL client APIs string"))?
.to_string_lossy(); .to_string_lossy();
client_apis client_apis
.split(' ') .split(' ')
@ -572,7 +586,7 @@ impl Inner {
} else { } else {
khronos_egl::OPENGL_ES_API khronos_egl::OPENGL_ES_API
}) })
.unwrap(); .map_err(instance_err("failed to bind API"))?;
let mut khr_context_flags = 0; let mut khr_context_flags = 0;
let supports_khr_context = display_extensions.contains("EGL_KHR_create_context"); let supports_khr_context = display_extensions.contains("EGL_KHR_create_context");
@ -661,7 +675,7 @@ impl Inner {
let result = if supports_opengl { let result = if supports_opengl {
egl.create_context(display, config, None, &gl_context_attributes) egl.create_context(display, config, None, &gl_context_attributes)
.or_else(|_| { .or_else(|_| {
egl.bind_api(khronos_egl::OPENGL_ES_API).unwrap(); egl.bind_api(khronos_egl::OPENGL_ES_API)?;
egl.create_context(display, config, None, &gles_context_attributes) egl.create_context(display, config, None, &gles_context_attributes)
}) })
} else { } else {
@ -848,15 +862,9 @@ impl crate::Instance for Instance {
} else { } else {
unsafe { khronos_egl::DynamicInstance::<khronos_egl::EGL1_4>::load_required() } unsafe { khronos_egl::DynamicInstance::<khronos_egl::EGL1_4>::load_required() }
}; };
let egl = match egl_result { let egl = egl_result
Ok(egl) => Arc::new(egl), .map(Arc::new)
Err(e) => { .map_err(instance_err("unable to open libEGL"))?;
return Err(crate::InstanceError::with_source(
String::from("unable to open libEGL"),
e,
));
}
};
let client_extensions = egl.query_string(None, khronos_egl::EXTENSIONS); let client_extensions = egl.query_string(None, khronos_egl::EXTENSIONS);
@ -891,75 +899,83 @@ impl crate::Instance for Instance {
#[cfg(Emscripten)] #[cfg(Emscripten)]
let egl1_5: Option<&Arc<EglInstance>> = Some(&egl); let egl1_5: Option<&Arc<EglInstance>> = Some(&egl);
let (display, display_owner, wsi_kind) = let (display, display_owner, wsi_kind) = if let (Some(library), Some(egl)) =
if let (Some(library), Some(egl)) = (wayland_library, egl1_5) { (wayland_library, egl1_5)
log::info!("Using Wayland platform"); {
let display_attributes = [khronos_egl::ATTRIB_NONE]; log::info!("Using Wayland platform");
let display = unsafe { let display_attributes = [khronos_egl::ATTRIB_NONE];
egl.get_platform_display( let display = unsafe {
EGL_PLATFORM_WAYLAND_KHR, egl.get_platform_display(
khronos_egl::DEFAULT_DISPLAY, EGL_PLATFORM_WAYLAND_KHR,
&display_attributes, khronos_egl::DEFAULT_DISPLAY,
) &display_attributes,
} )
.unwrap(); }
(display, Some(Rc::new(library)), WindowKind::Wayland) .map_err(instance_err("failed to get Wayland display"))?;
} else if let (Some(display_owner), Some(egl)) = (x11_display_library, egl1_5) { (display, Some(Rc::new(library)), WindowKind::Wayland)
log::info!("Using X11 platform"); } else if let (Some(display_owner), Some(egl)) = (x11_display_library, egl1_5) {
let display_attributes = [khronos_egl::ATTRIB_NONE]; log::info!("Using X11 platform");
let display = unsafe { let display_attributes = [khronos_egl::ATTRIB_NONE];
egl.get_platform_display( let display = unsafe {
EGL_PLATFORM_X11_KHR, egl.get_platform_display(
display_owner.display.as_ptr(), EGL_PLATFORM_X11_KHR,
&display_attributes, display_owner.display.as_ptr(),
) &display_attributes,
} )
.unwrap(); }
(display, Some(Rc::new(display_owner)), WindowKind::X11) .map_err(instance_err("failed to get x11 display"))?;
} else if let (Some(display_owner), Some(egl)) = (angle_x11_display_library, egl1_5) { (display, Some(Rc::new(display_owner)), WindowKind::X11)
log::info!("Using Angle platform with X11"); } else if let (Some(display_owner), Some(egl)) = (angle_x11_display_library, egl1_5) {
let display_attributes = [ log::info!("Using Angle platform with X11");
EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE as khronos_egl::Attrib, let display_attributes = [
EGL_PLATFORM_X11_KHR as khronos_egl::Attrib, EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE as khronos_egl::Attrib,
EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED as khronos_egl::Attrib, EGL_PLATFORM_X11_KHR as khronos_egl::Attrib,
usize::from(desc.flags.contains(wgt::InstanceFlags::VALIDATION)), EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED as khronos_egl::Attrib,
khronos_egl::ATTRIB_NONE, usize::from(desc.flags.contains(wgt::InstanceFlags::VALIDATION)),
]; khronos_egl::ATTRIB_NONE,
let display = unsafe { ];
egl.get_platform_display( let display = unsafe {
EGL_PLATFORM_ANGLE_ANGLE, egl.get_platform_display(
display_owner.display.as_ptr(), EGL_PLATFORM_ANGLE_ANGLE,
&display_attributes, display_owner.display.as_ptr(),
) &display_attributes,
} )
.unwrap(); }
(display, Some(Rc::new(display_owner)), WindowKind::AngleX11) .map_err(instance_err("failed to get Angle display"))?;
} else if client_ext_str.contains("EGL_MESA_platform_surfaceless") { (display, Some(Rc::new(display_owner)), WindowKind::AngleX11)
log::warn!("No windowing system present. Using surfaceless platform"); } else if client_ext_str.contains("EGL_MESA_platform_surfaceless") {
#[allow(clippy::unnecessary_literal_unwrap)] // This is only a literal on Emscripten log::warn!("No windowing system present. Using surfaceless platform");
let egl = egl1_5.expect("Failed to get EGL 1.5 for surfaceless"); #[allow(clippy::unnecessary_literal_unwrap)] // This is only a literal on Emscripten
let display = unsafe { let egl = egl1_5.expect("Failed to get EGL 1.5 for surfaceless");
egl.get_platform_display( let display = unsafe {
EGL_PLATFORM_SURFACELESS_MESA, egl.get_platform_display(
khronos_egl::DEFAULT_DISPLAY, EGL_PLATFORM_SURFACELESS_MESA,
&[khronos_egl::ATTRIB_NONE], khronos_egl::DEFAULT_DISPLAY,
) &[khronos_egl::ATTRIB_NONE],
} )
.unwrap(); }
.map_err(instance_err("failed to get MESA display"))?;
(display, None, WindowKind::Unknown) (display, None, WindowKind::Unknown)
} else { } else {
log::warn!("EGL_MESA_platform_surfaceless not available. Using default platform"); log::warn!("EGL_MESA_platform_surfaceless not available. Using default platform");
let display = unsafe { egl.get_display(khronos_egl::DEFAULT_DISPLAY) }.unwrap(); let display = unsafe { egl.get_display(khronos_egl::DEFAULT_DISPLAY) }
(display, None, WindowKind::Unknown) .ok_or_else(|| crate::InstanceError::new("Failed to get default display".into()))?;
}; (display, None, WindowKind::Unknown)
};
if desc.flags.contains(wgt::InstanceFlags::VALIDATION) if desc.flags.contains(wgt::InstanceFlags::VALIDATION)
&& client_ext_str.contains("EGL_KHR_debug") && client_ext_str.contains("EGL_KHR_debug")
{ {
log::debug!("Enabling EGL debug output"); log::debug!("Enabling EGL debug output");
let function: EglDebugMessageControlFun = { let function: EglDebugMessageControlFun = {
let addr = egl.get_proc_address("eglDebugMessageControlKHR").unwrap(); let addr = egl
.get_proc_address("eglDebugMessageControlKHR")
.ok_or_else(|| {
crate::InstanceError::new(
"failed to get `eglDebugMessageControlKHR` proc address".into(),
)
})?;
unsafe { core::mem::transmute(addr) } unsafe { core::mem::transmute(addr) }
}; };
let attributes = [ let attributes = [
@ -1021,7 +1037,7 @@ impl crate::Instance for Instance {
inner.config, inner.config,
khronos_egl::NATIVE_VISUAL_ID, khronos_egl::NATIVE_VISUAL_ID,
) )
.unwrap(); .map_err(instance_err("failed to get config NATIVE_VISUAL_ID"))?;
let ret = unsafe { let ret = unsafe {
ndk_sys::ANativeWindow_setBuffersGeometry( ndk_sys::ANativeWindow_setBuffersGeometry(
@ -1064,14 +1080,18 @@ impl crate::Instance for Instance {
.egl .egl
.instance .instance
.upcast::<khronos_egl::EGL1_5>() .upcast::<khronos_egl::EGL1_5>()
.unwrap() .ok_or_else(|| {
crate::InstanceError::new(
"EGL 1.5 is required for Wayland support".into(),
)
})?
.get_platform_display( .get_platform_display(
EGL_PLATFORM_WAYLAND_KHR, EGL_PLATFORM_WAYLAND_KHR,
display_handle.display.as_ptr(), display_handle.display.as_ptr(),
&display_attributes, &display_attributes,
) )
} }
.unwrap(); .map_err(instance_err("failed to get wayland display"))?;
let new_inner = Inner::create( let new_inner = Inner::create(
self.flags, self.flags,
@ -1237,7 +1257,9 @@ impl Surface {
) -> Result<(), crate::SurfaceError> { ) -> Result<(), crate::SurfaceError> {
let gl = unsafe { context.get_without_egl_lock() }; let gl = unsafe { context.get_without_egl_lock() };
let swapchain = self.swapchain.read(); let swapchain = self.swapchain.read();
let sc = swapchain.as_ref().unwrap(); let sc = swapchain.as_ref().ok_or(crate::SurfaceError::Other(
"Surface has no swap-chain configured",
))?;
self.egl self.egl
.instance .instance
@ -1363,9 +1385,20 @@ impl crate::Surface for Surface {
} }
(WindowKind::Unknown, Rwh::OhosNdk(handle)) => handle.native_window.as_ptr(), (WindowKind::Unknown, Rwh::OhosNdk(handle)) => handle.native_window.as_ptr(),
(WindowKind::Wayland, Rwh::Wayland(handle)) => { (WindowKind::Wayland, Rwh::Wayland(handle)) => {
let library = &self.wsi.display_owner.as_ref().unwrap().library; let library = &self
.wsi
.display_owner
.as_ref()
.ok_or(crate::SurfaceError::Other("No WSI display owner"))?
.library;
let wl_egl_window_create: libloading::Symbol<WlEglWindowCreateFun> = let wl_egl_window_create: libloading::Symbol<WlEglWindowCreateFun> =
unsafe { library.get(c"wl_egl_window_create".to_bytes()) }.unwrap(); unsafe { library.get(c"wl_egl_window_create".to_bytes()) }.map_err(
|_| {
crate::SurfaceError::Other(
"Failed to load `wl_egl_window_create",
)
},
)?;
let window = let window =
unsafe { wl_egl_window_create(handle.surface.as_ptr(), 640, 480) } unsafe { wl_egl_window_create(handle.surface.as_ptr(), 640, 480) }
.cast(); .cast();
@ -1475,9 +1508,16 @@ impl crate::Surface for Surface {
}; };
if let Some(window) = wl_window { if let Some(window) = wl_window {
let library = &self.wsi.display_owner.as_ref().unwrap().library; let library = &self
let wl_egl_window_resize: libloading::Symbol<WlEglWindowResizeFun> = .wsi
unsafe { library.get(c"wl_egl_window_resize".to_bytes()) }.unwrap(); .display_owner
.as_ref()
.ok_or(crate::SurfaceError::Other("No WSI display owner"))?
.library;
let wl_egl_window_resize: libloading::Symbol<WlEglWindowResizeFun> = unsafe {
library.get(c"wl_egl_window_resize".to_bytes())
}
.map_err(|_| crate::SurfaceError::Other("Failed to load `wl_egl_window_resize"))?;
unsafe { unsafe {
wl_egl_window_resize( wl_egl_window_resize(
window, window,
@ -1561,7 +1601,9 @@ impl crate::Surface for Surface {
_fence: &super::Fence, _fence: &super::Fence,
) -> Result<Option<crate::AcquiredSurfaceTexture<super::Api>>, crate::SurfaceError> { ) -> Result<Option<crate::AcquiredSurfaceTexture<super::Api>>, crate::SurfaceError> {
let swapchain = self.swapchain.read(); let swapchain = self.swapchain.read();
let sc = swapchain.as_ref().unwrap(); let sc = swapchain.as_ref().ok_or(crate::SurfaceError::Other(
"Surface has no swap-chain configured",
))?;
let texture = super::Texture { let texture = super::Texture {
inner: super::TextureInner::Renderbuffer { inner: super::TextureInner::Renderbuffer {
raw: sc.renderbuffer, raw: sc.renderbuffer,