use std::sync::Arc;
use parking_lot::RwLock;
use super::{ImageData, ImagePixelFormat, NativeImageBackend, NativeImageData};
static ORDER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
pub(crate) fn next_in_order() -> u64 {
ORDER.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
thread_local! {
static RUNS_FOR: std::cell::Cell<Option<u64>> = const { std::cell::Cell::new(None) };
}
pub(crate) fn for_device<R>(device: u64, run: impl FnOnce() -> R) -> R {
struct Back(Option<u64>);
impl Drop for Back {
fn drop(&mut self) {
RUNS_FOR.set(self.0);
}
}
let _back = Back(RUNS_FOR.replace(Some(device)));
run()
}
#[derive(Clone)]
pub struct WgpuExternalImageSlot {
state: WgpuExternalImageState,
native: NativeImageData,
}
#[derive(Clone)]
pub(crate) struct WgpuExternalImageState {
inner: Arc<RwLock<WgpuExternalImageSlotState>>,
}
struct WgpuExternalImageSlotState {
view: Option<wgpu::TextureView>,
width: u32,
height: u32,
version: u64,
of: Option<u64>,
given: u64,
}
#[derive(Clone)]
pub(crate) struct WgpuExternalImageWeak {
inner: std::sync::Weak<RwLock<WgpuExternalImageSlotState>>,
}
impl WgpuExternalImageWeak {
pub(crate) fn upgrade(&self) -> Option<WgpuExternalImageState> {
Some(WgpuExternalImageState {
inner: self.inner.upgrade()?,
})
}
pub(crate) fn is(&self, state: &WgpuExternalImageState) -> bool {
std::ptr::eq(self.inner.as_ptr(), Arc::as_ptr(&state.inner))
}
}
fn of_device(of: Option<u64>, given: u64, device: u64) -> bool {
match of {
Some(of) => of == device,
None => given > device,
}
}
#[derive(Clone)]
pub(crate) struct WgpuExternalImageSnapshot {
pub view: wgpu::TextureView,
pub width: u32,
pub height: u32,
pub version: u64,
pub of: Option<u64>,
pub given: u64,
}
impl WgpuExternalImageSnapshot {
pub(crate) fn is_of(&self, device: u64) -> bool {
of_device(self.of, self.given, device)
}
}
impl Default for WgpuExternalImageSlot {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WgpuTextureError {
NotSampled,
NotTwoDimensional(wgpu::TextureDimension),
Multisampled(u32),
Format(wgpu::TextureFormat),
}
impl std::fmt::Display for WgpuTextureError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NotSampled => write!(formatter, "the texture was made without TextureUsages::TEXTURE_BINDING"),
Self::NotTwoDimensional(dimension) => write!(formatter, "the texture is {dimension:?}, not D2"),
Self::Multisampled(samples) => write!(formatter, "the texture has {samples} samples: resolve it into one of 1"),
Self::Format(format) => write!(
formatter,
"lurq does not read {format:?} as filtered color: use an sRGB, unorm or 16-bit float format"
),
}
}
}
impl std::error::Error for WgpuTextureError {}
fn sampled_as_color(texture: &wgpu::Texture) -> Result<(), WgpuTextureError> {
if !texture.usage().contains(wgpu::TextureUsages::TEXTURE_BINDING) {
return Err(WgpuTextureError::NotSampled);
}
if texture.dimension() != wgpu::TextureDimension::D2 {
return Err(WgpuTextureError::NotTwoDimensional(texture.dimension()));
}
if texture.sample_count() != 1 {
return Err(WgpuTextureError::Multisampled(texture.sample_count()));
}
match texture.format().sample_type(None, None) {
Some(wgpu::TextureSampleType::Float { filterable: true }) => Ok(()),
_ => Err(WgpuTextureError::Format(texture.format())),
}
}
impl WgpuExternalImageSlot {
pub fn new() -> Self {
let state = WgpuExternalImageState {
inner: Arc::new(RwLock::new(WgpuExternalImageSlotState {
view: None,
width: 1,
height: 1,
version: 0,
of: None,
given: 0,
})),
};
let native = NativeImageData::new(
1,
1,
ImagePixelFormat::Rgba8,
NativeImageBackend::WgpuExternalRgba,
state.clone(),
);
Self { state, native }
}
pub fn image_id(&self) -> u64 {
self.native.id()
}
pub fn image_data(&self) -> ImageData {
self.native.image_data()
}
pub fn set_texture_view(&self, view: wgpu::TextureView, width: u32, height: u32) -> Result<u64, WgpuTextureError> {
self.give(view, width, height, RUNS_FOR.get())
}
pub fn set_texture_view_of(
&self,
gpu: &crate::app::wgpu_render::SharedWgpuContext,
view: wgpu::TextureView,
width: u32,
height: u32,
) -> Result<u64, WgpuTextureError> {
self.give(view, width, height, Some(gpu.number))
}
fn give(&self, view: wgpu::TextureView, width: u32, height: u32, of: Option<u64>) -> Result<u64, WgpuTextureError> {
if let Err(error) = sampled_as_color(view.texture()) {
tracing::error!("a GpuViewport's slot refused a texture view: {error}");
return Err(error);
}
let mut state = self.state.inner.write();
state.version = state.version.wrapping_add(1);
state.view = Some(view);
state.of = of;
state.given = next_in_order();
state.width = width.max(1);
state.height = height.max(1);
Ok(state.version)
}
pub fn clear(&self) -> u64 {
let mut state = self.state.inner.write();
state.version = state.version.wrapping_add(1);
state.view = None;
state.version
}
pub fn version(&self) -> u64 {
self.state.version()
}
}
impl WgpuExternalImageState {
pub(crate) fn version(&self) -> u64 {
self.inner.read().version
}
pub(crate) fn downgrade(&self) -> WgpuExternalImageWeak {
WgpuExternalImageWeak {
inner: Arc::downgrade(&self.inner),
}
}
pub(crate) fn forget_view_of(&self, device: u64) {
let mut state = self.inner.write();
if state.view.is_some() && of_device(state.of, state.given, device) {
state.view = None;
state.version = state.version.wrapping_add(1);
}
}
pub(crate) fn snapshot(&self) -> Option<WgpuExternalImageSnapshot> {
let state = self.inner.read();
Some(WgpuExternalImageSnapshot {
view: state.view.clone()?,
width: state.width,
height: state.height,
version: state.version,
of: state.of,
given: state.given,
})
}
}
#[cfg(test)]
mod tests {
use super::WgpuExternalImageSlot;
#[test]
fn slot_has_stable_image_identity_and_version() {
let slot = WgpuExternalImageSlot::new();
let clone = slot.clone();
assert_eq!(slot.image_id(), clone.image_id());
assert_eq!(slot.image_data().id(), slot.image_id());
assert_eq!(slot.version(), 0);
assert_eq!(clone.clear(), 1);
assert_eq!(slot.version(), 1);
}
#[test]
fn a_view_is_of_the_device_it_was_given_for_and_of_no_device_made_after_it() {
use super::{WgpuExternalImageSnapshot, for_device, next_in_order};
let Some(gpu) = any_device() else {
eprintln!("skipped: no card to make a texture on");
return;
};
let view = any_view_of(&gpu);
let snapshot = |slot: &WgpuExternalImageSlot| -> WgpuExternalImageSnapshot {
slot.state.snapshot().expect("the view that was given")
};
let (first, slot) = (next_in_order(), WgpuExternalImageSlot::new());
for_device(first, || slot.set_texture_view(view.clone(), 4, 4)).unwrap();
let second = next_in_order();
assert!(snapshot(&slot).is_of(first));
assert!(
!snapshot(&slot).is_of(second),
"a view of the device before is not the next one's"
);
for_device(second, || slot.set_texture_view(view.clone(), 4, 4)).unwrap();
assert!(snapshot(&slot).is_of(second) && !snapshot(&slot).is_of(first));
slot.set_texture_view(view.clone(), 4, 4).unwrap();
let third = next_in_order();
assert!(snapshot(&slot).is_of(second));
assert!(!snapshot(&slot).is_of(third));
let view = snapshot(&slot).view;
for_device(second, || slot.set_texture_view(view, 4, 4)).unwrap();
slot.state.forget_view_of(first);
assert!(slot.state.snapshot().is_some(), "the view is of the second, and stays");
let version = slot.version();
slot.state.forget_view_of(second);
assert!(slot.state.snapshot().is_none());
assert_eq!(slot.version(), version + 1, "an empty slot is another picture");
let weak = slot.state.downgrade();
assert!(weak.is(&slot.state) && weak.upgrade().is_some());
let fourth = next_in_order();
let view = any_view_of(&gpu);
let lost = crate::app::wgpu_render::SharedWgpuContext { number: first, ..gpu };
slot.set_texture_view_of(&lost, view, 4, 4).unwrap();
assert!(snapshot(&slot).is_of(first));
assert!(
!snapshot(&slot).is_of(fourth),
"a view of a lost device, given late, is not the next one's"
);
for_device(first, || {
for_device(second, || {});
slot.clear();
});
}
fn any_device() -> Option<crate::app::wgpu_render::SharedWgpuContext> {
let mut descriptor = wgpu::InstanceDescriptor::new_without_display_handle();
descriptor.backends = if cfg!(windows) {
wgpu::Backends::DX12
} else {
wgpu::Backends::all()
};
let instance = wgpu::Instance::new(descriptor);
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())).ok()?;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()?;
Some(crate::app::wgpu_render::SharedWgpuContext {
instance,
adapter,
device,
queue,
surface_format: wgpu::TextureFormat::Rgba8Unorm,
number: 0,
})
}
fn any_view_of(gpu: &crate::app::wgpu_render::SharedWgpuContext) -> wgpu::TextureView {
let texture = gpu.device.create_texture(&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: 4,
height: 4,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
texture.create_view(&Default::default())
}
}