use std::{cell::Cell, sync::Arc};
use parking_lot::Mutex;
use super::WgpuAppError;
thread_local! {
static OWN: Cell<bool> = const { Cell::new(false) };
}
pub(super) struct OwnWork(bool);
impl OwnWork {
pub(super) fn begin() -> Self {
Self(OWN.replace(true))
}
}
impl Drop for OwnWork {
fn drop(&mut self) {
OWN.set(self.0);
}
}
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(super) fn is_own() -> bool {
OWN.get()
}
pub(super) fn apps<R>(call: impl FnOnce() -> R) -> R {
let own = OWN.replace(false);
let result = call();
OWN.set(own);
result
}
#[derive(Clone, Default)]
pub(super) struct Untold(Arc<Mutex<Vec<WgpuAppError>>>);
impl Untold {
pub(super) fn push(&self, error: WgpuAppError) {
let mut untold = self.0.lock();
if untold.len() < 64 {
untold.push(error);
}
}
pub(super) fn take(&self) -> Vec<WgpuAppError> {
std::mem::take(&mut *self.0.lock())
}
}
pub(super) fn log(error: &WgpuAppError) {
tracing::error!("a wgpu call of the app failed, which ends nothing: {error}");
}
pub(super) fn caught<R>(device: &wgpu::Device, untold: &Untold, call: impl FnOnce() -> R) -> (R, Vec<WgpuAppError>) {
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let memory = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
let result = apps(call);
let scopes = [internal.pop(), memory.pop(), validation.pop()];
#[cfg(not(target_arch = "wasm32"))]
{
let _ = untold;
let errors = scopes
.into_iter()
.filter_map(pollster::block_on)
.map(WgpuAppError::from)
.collect::<Vec<_>>();
errors.iter().for_each(log);
(result, errors)
}
#[cfg(target_arch = "wasm32")]
{
for scope in scopes {
let untold = untold.clone();
wasm_bindgen_futures::spawn_local(async move {
if let Some(error) = scope.await {
let error = WgpuAppError::from(error);
log(&error);
untold.push(error);
}
});
}
(result, Vec::new())
}
}