use crate::error::{BarracudaError, Result};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, Ordering};
use wgpu::util::DeviceExt;
pub struct GuardedEncoder {
encoder: Option<wgpu::CommandEncoder>,
active_encoders: Arc<AtomicU32>,
}
impl std::ops::Deref for GuardedEncoder {
type Target = wgpu::CommandEncoder;
#[expect(
clippy::expect_used,
reason = "Deref requires &T; encoder is Some until finish() consumes self"
)]
fn deref(&self) -> &Self::Target {
self.encoder
.as_ref()
.expect("GuardedEncoder::deref after finish (unreachable by ownership)")
}
}
impl std::ops::DerefMut for GuardedEncoder {
#[expect(
clippy::expect_used,
reason = "DerefMut requires &mut T; encoder is Some until finish() consumes self"
)]
fn deref_mut(&mut self) -> &mut Self::Target {
self.encoder
.as_mut()
.expect("GuardedEncoder::deref_mut after finish (unreachable by ownership)")
}
}
impl GuardedEncoder {
pub(crate) fn new(encoder: wgpu::CommandEncoder, active_encoders: Arc<AtomicU32>) -> Self {
Self {
encoder: Some(encoder),
active_encoders,
}
}
pub fn encoder(&self) -> Result<&wgpu::CommandEncoder> {
self.encoder
.as_ref()
.ok_or_else(|| BarracudaError::Internal("encoder already finished".into()))
}
pub fn encoder_mut(&mut self) -> Result<&mut wgpu::CommandEncoder> {
self.encoder
.as_mut()
.ok_or_else(|| BarracudaError::Internal("encoder already finished".into()))
}
#[must_use]
#[expect(
clippy::expect_used,
reason = "finish consumes self; Option::None here means double-call (unreachable)"
)]
pub fn finish(mut self) -> wgpu::CommandBuffer {
let encoder = self
.encoder
.take()
.expect("GuardedEncoder::finish called twice (unreachable by ownership)");
self.active_encoders.fetch_sub(1, Ordering::Release);
encoder.finish()
}
}
impl Drop for GuardedEncoder {
fn drop(&mut self) {
if self.encoder.is_some() {
self.active_encoders.fetch_sub(1, Ordering::Release);
}
}
}
#[derive(Clone)]
pub struct GuardedDeviceHandle {
inner: wgpu::Device,
active_encoders: Arc<AtomicU32>,
}
impl std::fmt::Debug for GuardedDeviceHandle {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GuardedDeviceHandle")
.field("inner", &"<wgpu::Device>")
.finish()
}
}
impl std::ops::Deref for GuardedDeviceHandle {
type Target = wgpu::Device;
fn deref(&self) -> &wgpu::Device {
&self.inner
}
}
impl GuardedDeviceHandle {
pub(crate) fn new(inner: wgpu::Device, active_encoders: Arc<AtomicU32>) -> Self {
Self {
inner,
active_encoders,
}
}
fn guard(&self) {
self.active_encoders.fetch_add(1, Ordering::Acquire);
}
fn unguard(&self) {
self.active_encoders.fetch_sub(1, Ordering::Release);
}
#[must_use]
pub fn create_buffer(&self, desc: &wgpu::BufferDescriptor<'_>) -> wgpu::Buffer {
self.guard();
let r = self.inner.create_buffer(desc);
self.unguard();
r
}
#[must_use]
pub fn create_buffer_init(&self, desc: &wgpu::util::BufferInitDescriptor<'_>) -> wgpu::Buffer {
self.guard();
let r = self.inner.create_buffer_init(desc);
self.unguard();
r
}
#[must_use]
pub fn create_bind_group_layout(
&self,
desc: &wgpu::BindGroupLayoutDescriptor<'_>,
) -> wgpu::BindGroupLayout {
self.guard();
let r = self.inner.create_bind_group_layout(desc);
self.unguard();
r
}
#[must_use]
pub fn create_bind_group(&self, desc: &wgpu::BindGroupDescriptor<'_>) -> wgpu::BindGroup {
self.guard();
let r = self.inner.create_bind_group(desc);
self.unguard();
r
}
#[must_use]
pub fn create_pipeline_layout(
&self,
desc: &wgpu::PipelineLayoutDescriptor<'_>,
) -> wgpu::PipelineLayout {
self.guard();
let r = self.inner.create_pipeline_layout(desc);
self.unguard();
r
}
#[must_use]
pub fn create_compute_pipeline(
&self,
desc: &wgpu::ComputePipelineDescriptor<'_>,
) -> wgpu::ComputePipeline {
self.guard();
let r = self.inner.create_compute_pipeline(desc);
self.unguard();
r
}
#[must_use]
pub fn create_shader_module(
&self,
desc: wgpu::ShaderModuleDescriptor<'_>,
) -> wgpu::ShaderModule {
self.guard();
let r = self.inner.create_shader_module(desc);
self.unguard();
r
}
#[must_use]
pub fn create_command_encoder(
&self,
desc: &wgpu::CommandEncoderDescriptor<'_>,
) -> wgpu::CommandEncoder {
self.guard();
let r = self.inner.create_command_encoder(desc);
self.unguard();
r
}
}