[core] Add RawResourceAccess trait

wgpu-core/src/as_hal.rs

@@ -5,7 +5,7 @@ use crate::{
         AdapterId, BlasId, BufferId, CommandEncoderId, DeviceId, QueueId, SurfaceId, TextureId,
         TextureViewId, TlasId,
     },
-    resource::AccelerationStructure,
+    resource::RawResourceAccess,
 };
 
 impl Global {

wgpu-core/src/binding_model.rs

@@ -26,7 +26,8 @@ use crate::{
     pipeline::{ComputePipeline, RenderPipeline},
     resource::{
         Buffer, DestroyedResourceError, InvalidResourceError, Labeled, MissingBufferUsageError,
-        MissingTextureUsageError, ResourceErrorIdent, Sampler, TextureView, Tlas, TrackingData,
+        MissingTextureUsageError, RawResourceAccess, ResourceErrorIdent, Sampler, TextureView,
+        Tlas, TrackingData,
     },
     resource_log,
     snatch::{SnatchGuard, Snatchable},

wgpu-core/src/command/bundle.rs

@@ -111,7 +111,7 @@ use crate::{
     pipeline::{PipelineFlags, RenderPipeline, VertexStep},
     resource::{
         Buffer, DestroyedResourceError, Fallible, InvalidResourceError, Labeled, ParentDevice,
-        TrackingData,
+        RawResourceAccess, TrackingData,
     },
     resource_log,
     snatch::SnatchGuard,

wgpu-core/src/command/clear.rs

@@ -13,7 +13,7 @@ use crate::{
     init_tracker::{MemoryInitKind, TextureInitRange},
     resource::{
         DestroyedResourceError, InvalidResourceError, Labeled, MissingBufferUsageError,
-        ParentDevice, ResourceErrorIdent, Texture, TextureClearMode,
+        ParentDevice, RawResourceAccess, ResourceErrorIdent, Texture, TextureClearMode,
     },
     snatch::SnatchGuard,
     track::TextureTrackerSetSingle,

wgpu-core/src/command/compute.rs

@@ -7,9 +7,9 @@ use wgt::{
 use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
 use core::{fmt, str};
 
-use crate::binding_model::BindError;
 use crate::command::{pass, EncoderStateError, PassStateError, TimestampWritesError};
 use crate::resource::DestroyedResourceError;
+use crate::{binding_model::BindError, resource::RawResourceAccess};
 use crate::{
     binding_model::{LateMinBufferBindingSizeMismatch, PushConstantUploadError},
     command::{

wgpu-core/src/command/memory_init.rs

@@ -9,7 +9,7 @@ use hashbrown::hash_map::Entry;
 use crate::{
     device::Device,
     init_tracker::*,
-    resource::{DestroyedResourceError, ParentDevice, Texture, Trackable},
+    resource::{DestroyedResourceError, ParentDevice, RawResourceAccess, Texture, Trackable},
     snatch::SnatchGuard,
     track::{DeviceTracker, TextureTracker},
     FastHashMap,

wgpu-core/src/command/query.rs

@@ -11,7 +11,7 @@ use crate::{
     init_tracker::MemoryInitKind,
     resource::{
         DestroyedResourceError, InvalidResourceError, MissingBufferUsageError, ParentDevice,
-        QuerySet, Trackable,
+        QuerySet, RawResourceAccess, Trackable,
     },
     track::{StatelessTracker, TrackerIndex},
     FastHashMap,

wgpu-core/src/command/ray_tracing.rs

@@ -7,7 +7,6 @@ use core::{
 
 use wgt::{math::align_to, BufferUsages, BufferUses, Features};
 
-use crate::lock::RwLockWriteGuard;
 use crate::ray_tracing::{AsAction, AsBuild, TlasBuild, ValidateAsActionsError};
 use crate::{
     command::CommandBufferMutable,
@@ -21,14 +20,13 @@ use crate::{
         TlasInstance, TlasPackage, TraceBlasBuildEntry, TraceBlasGeometries,
         TraceBlasTriangleGeometry, TraceTlasInstance, TraceTlasPackage,
     },
-    resource::{
-        AccelerationStructure, Blas, BlasCompactState, Buffer, Labeled, StagingBuffer, Tlas,
-    },
+    resource::{Blas, BlasCompactState, Buffer, Labeled, StagingBuffer, Tlas},
     scratch::ScratchBuffer,
     snatch::SnatchGuard,
     track::PendingTransition,
 };
 use crate::{command::EncoderStateError, device::resource::CommandIndices};
+use crate::{lock::RwLockWriteGuard, resource::RawResourceAccess};
 
 use crate::id::{BlasId, TlasId};
 

wgpu-core/src/command/render.rs

@@ -15,6 +15,7 @@ use crate::command::{
     TimestampWritesError,
 };
 use crate::pipeline::{RenderPipeline, VertexStep};
+use crate::resource::RawResourceAccess;
 use crate::resource::{InvalidResourceError, ResourceErrorIdent};
 use crate::snatch::SnatchGuard;
 use crate::{

wgpu-core/src/command/transfer.rs

@@ -22,8 +22,8 @@ use crate::{
         TextureInitTrackerAction,
     },
     resource::{
-        MissingBufferUsageError, MissingTextureUsageError, ParentDevice, Texture,
-        TextureErrorDimension,
+        MissingBufferUsageError, MissingTextureUsageError, ParentDevice, RawResourceAccess,
+        Texture, TextureErrorDimension,
     },
     snatch::SnatchGuard,
 };

wgpu-core/src/device/global.rs

@@ -207,6 +207,8 @@ impl Global {
         offset: BufferAddress,
         data: &[u8],
     ) -> BufferAccessResult {
+        use crate::resource::RawResourceAccess;
+
         let hub = &self.hub;
 
         let buffer = hub.buffers.get(buffer_id).get()?;

wgpu-core/src/device/mod.rs

@@ -8,7 +8,7 @@ use crate::{
     ray_tracing::BlasCompactReadyPendingClosure,
     resource::{
         Buffer, BufferAccessError, BufferAccessResult, BufferMapOperation, Labeled,
-        ResourceErrorIdent,
+        RawResourceAccess, ResourceErrorIdent,
     },
     snatch::SnatchGuard,
     Label, DOWNLEVEL_ERROR_MESSAGE,

wgpu-core/src/device/queue.rs

@@ -14,7 +14,6 @@ use wgt::{
 };
 
 use super::{life::LifetimeTracker, Device};
-use crate::device::resource::CommandIndices;
 #[cfg(feature = "trace")]
 use crate::device::trace::Action;
 use crate::{
@@ -33,8 +32,8 @@ use crate::{
     lock::{rank, Mutex, MutexGuard, RwLock, RwLockWriteGuard},
     ray_tracing::{BlasCompactReadyPendingClosure, CompactBlasError},
     resource::{
-        AccelerationStructure, Blas, BlasCompactState, Buffer, BufferAccessError, BufferMapState,
-        DestroyedBuffer, DestroyedResourceError, DestroyedTexture, Fallible, FlushedStagingBuffer,
+        Blas, BlasCompactState, Buffer, BufferAccessError, BufferMapState, DestroyedBuffer,
+        DestroyedResourceError, DestroyedTexture, Fallible, FlushedStagingBuffer,
         InvalidResourceError, Labeled, ParentDevice, ResourceErrorIdent, StagingBuffer, Texture,
         TextureInner, Trackable, TrackingData,
     },
@@ -44,6 +43,7 @@ use crate::{
     track::{self, Tracker, TrackerIndex},
     FastHashMap, SubmissionIndex,
 };
+use crate::{device::resource::CommandIndices, resource::RawResourceAccess};
 
 pub struct Queue {
     raw: Box<dyn hal::DynQueue>,

wgpu-core/src/device/resource.rs

@@ -40,7 +40,7 @@ use crate::{
     pipeline,
     pool::ResourcePool,
     resource::{
-        self, AccelerationStructure, Buffer, Fallible, Labeled, ParentDevice, QuerySet, Sampler,
+        self, Buffer, Fallible, Labeled, ParentDevice, QuerySet, RawResourceAccess, Sampler,
         StagingBuffer, Texture, TextureView, TextureViewNotRenderableReason, Tlas, TrackingData,
     },
     resource_log,

wgpu-core/src/resource.rs

@@ -135,6 +135,29 @@ macro_rules! impl_parent_device {
     };
 }
 
+/// Allow access to the hal resource as guarded by the `SnatchGuard`.
+pub trait RawResourceAccess: ParentDevice {
+    type DynResource: hal::DynResource + ?Sized;
+
+    /// Get access to the raw resource if it is not destroyed.
+    ///
+    /// Returns `None` if the resource has been destroyed. This method
+    /// does not allocate in either case.
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource>;
+
+    /// Get access to the raw resource if it is not destroyed.
+    ///
+    /// Returns a full error if the resource has been destroyed. This
+    /// method allocates a label in the error case.
+    fn try_raw<'a>(
+        &'a self,
+        guard: &'a SnatchGuard,
+    ) -> Result<&'a Self::DynResource, DestroyedResourceError> {
+        self.raw(guard)
+            .ok_or_else(|| DestroyedResourceError(self.error_ident()))
+    }
+}
+
 pub trait ResourceType {
     const TYPE: &'static str;
 }
@@ -435,21 +458,15 @@ impl Drop for Buffer {
     }
 }
 
-impl Buffer {
-    pub(crate) fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a dyn hal::DynBuffer> {
+impl RawResourceAccess for Buffer {
+    type DynResource = dyn hal::DynBuffer;
+
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
         self.raw.get(guard).map(|b| b.as_ref())
     }
+}
 
-    pub(crate) fn try_raw<'a>(
-        &'a self,
-        guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynBuffer, DestroyedResourceError> {
-        self.raw
-            .get(guard)
-            .map(|raw| raw.as_ref())
-            .ok_or_else(|| DestroyedResourceError(self.error_ident()))
-    }
-
+impl Buffer {
     pub(crate) fn check_destroyed(
         &self,
         guard: &SnatchGuard,
@@ -1182,6 +1199,14 @@ impl Drop for Texture {
     }
 }
 
+impl RawResourceAccess for Texture {
+    type DynResource = dyn hal::DynTexture;
+
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
+        self.inner.get(guard).map(|t| t.raw())
+    }
+}
+
 impl Texture {
     pub(crate) fn try_inner<'a>(
         &'a self,
@@ -1192,23 +1217,6 @@ impl Texture {
             .ok_or_else(|| DestroyedResourceError(self.error_ident()))
     }
 
-    pub(crate) fn raw<'a>(
-        &'a self,
-        snatch_guard: &'a SnatchGuard,
-    ) -> Option<&'a dyn hal::DynTexture> {
-        Some(self.inner.get(snatch_guard)?.raw())
-    }
-
-    pub(crate) fn try_raw<'a>(
-        &'a self,
-        guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynTexture, DestroyedResourceError> {
-        self.inner
-            .get(guard)
-            .map(|t| t.raw())
-            .ok_or_else(|| DestroyedResourceError(self.error_ident()))
-    }
-
     pub(crate) fn check_destroyed(
         &self,
         guard: &SnatchGuard,
@@ -1570,25 +1578,25 @@ impl Drop for TextureView {
     }
 }
 
-impl TextureView {
-    pub(crate) fn raw<'a>(
-        &'a self,
-        snatch_guard: &'a SnatchGuard,
-    ) -> Option<&'a dyn hal::DynTextureView> {
-        self.raw.get(snatch_guard).map(|it| it.as_ref())
+impl RawResourceAccess for TextureView {
+    type DynResource = dyn hal::DynTextureView;
+
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
+        self.raw.get(guard).map(|it| it.as_ref())
     }
 
-    pub(crate) fn try_raw<'a>(
+    fn try_raw<'a>(
         &'a self,
         guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynTextureView, DestroyedResourceError> {
+    ) -> Result<&'a Self::DynResource, DestroyedResourceError> {
         self.parent.check_destroyed(guard)?;
-        self.raw
-            .get(guard)
-            .map(|it| it.as_ref())
+
+        self.raw(guard)
             .ok_or_else(|| DestroyedResourceError(self.error_ident()))
     }
+}
 
+impl TextureView {
     /// Checks that the given texture usage contains the required texture usage,
     /// returns an error otherwise.
     pub(crate) fn check_usage(
@@ -1888,13 +1896,6 @@ impl QuerySet {
 pub type BlasDescriptor<'a> = wgt::CreateBlasDescriptor<Label<'a>>;
 pub type TlasDescriptor<'a> = wgt::CreateTlasDescriptor<Label<'a>>;
 
-pub(crate) trait AccelerationStructure: Trackable {
-    fn try_raw<'a>(
-        &'a self,
-        guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError>;
-}
-
 pub type BlasPrepareCompactResult = Result<(), BlasPrepareCompactError>;
 
 #[cfg(send_sync)]
@@ -1970,15 +1971,11 @@ impl Drop for Blas {
     }
 }
 
-impl AccelerationStructure for Blas {
-    fn try_raw<'a>(
-        &'a self,
-        guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError> {
-        self.raw
-            .get(guard)
-            .map(|raw| raw.as_ref())
-            .ok_or_else(|| DestroyedResourceError(self.error_ident()))
+impl RawResourceAccess for Blas {
+    type DynResource = dyn hal::DynAccelerationStructure;
+
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
+        self.raw.get(guard).map(|it| it.as_ref())
     }
 }
 
@@ -2118,15 +2115,11 @@ impl Drop for Tlas {
     }
 }
 
-impl AccelerationStructure for Tlas {
-    fn try_raw<'a>(
-        &'a self,
-        guard: &'a SnatchGuard,
-    ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError> {
-        self.raw
-            .get(guard)
-            .map(|raw| raw.as_ref())
-            .ok_or_else(|| DestroyedResourceError(self.error_ident()))
+impl RawResourceAccess for Tlas {
+    type DynResource = dyn hal::DynAccelerationStructure;
+
+    fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
+        self.raw.get(guard).map(|raw| raw.as_ref())
     }
 }
 

wgpu-core/src/track/mod.rs

@@ -106,7 +106,7 @@ use crate::{
     binding_model, command,
     lock::{rank, Mutex},
     pipeline,
-    resource::{self, Labeled, ResourceErrorIdent},
+    resource::{self, Labeled, RawResourceAccess, ResourceErrorIdent},
     snatch::SnatchGuard,
     track::blas::BlasTracker,
 };

wgpu-core/src/track/texture.rs

@@ -20,7 +20,7 @@
 
 use super::{range::RangedStates, PendingTransition, PendingTransitionList};
 use crate::{
-    resource::{Texture, TextureInner, TextureView, Trackable},
+    resource::{RawResourceAccess, Texture, TextureInner, TextureView, Trackable},
     snatch::SnatchGuard,
     track::{
         invalid_resource_state, skip_barrier, ResourceMetadata, ResourceMetadataProvider,