[wgpu-core] Allow creation of bind groups containing external textures

Adds a `BindingResource` variant for external textures. In core's
create_bind_group() implementation, allow binding either external
textures or texture views to `BindingType::ExternalTexture` layout
entries.

In either case, provide HAL with a `hal::ExternalTextureBinding`,
consisting of 3 `hal::TextureBinding`s and a `hal::BufferBinding`. In
the texture view case we use the device's default params buffer for
the buffer. When there are fewer than 3 planes we can simply repeat an
existing plane multiple times - the contents of the params buffer will
ensure the shader only accesses the correct number of planes anyway.

Track the view or external texture in `BindGroupStates` to ensure they
remain alive whilst required.

And finally, add the corresponding API to wgpu, with an implementation
for the wgpu-core backend.

Author: jamienicol

wgpu-core/src/binding_model.rs

@@ -19,12 +19,13 @@ use crate::{
     device::{
         bgl, Device, DeviceError, MissingDownlevelFlags, MissingFeatures, SHADER_STAGE_COUNT,
     },
-    id::{BindGroupLayoutId, BufferId, SamplerId, TextureViewId, TlasId},
+    id::{BindGroupLayoutId, BufferId, ExternalTextureId, SamplerId, TextureViewId, TlasId},
     init_tracker::{BufferInitTrackerAction, TextureInitTrackerAction},
     pipeline::{ComputePipeline, RenderPipeline},
     resource::{
-        Buffer, DestroyedResourceError, InvalidResourceError, Labeled, MissingBufferUsageError,
-        MissingTextureUsageError, ResourceErrorIdent, Sampler, TextureView, Tlas, TrackingData,
+        Buffer, DestroyedResourceError, ExternalTexture, InvalidResourceError, Labeled,
+        MissingBufferUsageError, MissingTextureUsageError, ResourceErrorIdent, Sampler,
+        TextureView, Tlas, TrackingData,
     },
     resource_log,
     snatch::{SnatchGuard, Snatchable},
@@ -492,8 +493,14 @@ impl BindingTypeMaxCountValidator {
 /// cbindgen:ignore
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct BindGroupEntry<'a, B = BufferId, S = SamplerId, TV = TextureViewId, TLAS = TlasId>
-where
+pub struct BindGroupEntry<
+    'a,
+    B = BufferId,
+    S = SamplerId,
+    TV = TextureViewId,
+    TLAS = TlasId,
+    ET = ExternalTextureId,
+> where
     [BufferBinding<B>]: ToOwned,
     [S]: ToOwned,
     [TV]: ToOwned,
@@ -506,15 +513,21 @@ where
     pub binding: u32,
     #[cfg_attr(
         feature = "serde",
-        serde(bound(deserialize = "BindingResource<'a, B, S, TV, TLAS>: Deserialize<'de>"))
+        serde(bound(deserialize = "BindingResource<'a, B, S, TV, TLAS, ET>: Deserialize<'de>"))
     )]
     /// Resource to attach to the binding
-    pub resource: BindingResource<'a, B, S, TV, TLAS>,
+    pub resource: BindingResource<'a, B, S, TV, TLAS, ET>,
 }
 
 /// cbindgen:ignore
-pub type ResolvedBindGroupEntry<'a> =
-    BindGroupEntry<'a, Arc<Buffer>, Arc<Sampler>, Arc<TextureView>, Arc<Tlas>>;
+pub type ResolvedBindGroupEntry<'a> = BindGroupEntry<
+    'a,
+    Arc<Buffer>,
+    Arc<Sampler>,
+    Arc<TextureView>,
+    Arc<Tlas>,
+    Arc<ExternalTexture>,
+>;
 
 /// Describes a group of bindings and the resources to be bound.
 #[derive(Clone, Debug)]
@@ -526,15 +539,16 @@ pub struct BindGroupDescriptor<
     S = SamplerId,
     TV = TextureViewId,
     TLAS = TlasId,
+    ET = ExternalTextureId,
 > where
     [BufferBinding<B>]: ToOwned,
     [S]: ToOwned,
     [TV]: ToOwned,
     <[BufferBinding<B>] as ToOwned>::Owned: fmt::Debug,
     <[S] as ToOwned>::Owned: fmt::Debug,
     <[TV] as ToOwned>::Owned: fmt::Debug,
-    [BindGroupEntry<'a, B, S, TV, TLAS>]: ToOwned,
-    <[BindGroupEntry<'a, B, S, TV, TLAS>] as ToOwned>::Owned: fmt::Debug,
+    [BindGroupEntry<'a, B, S, TV, TLAS, ET>]: ToOwned,
+    <[BindGroupEntry<'a, B, S, TV, TLAS, ET>] as ToOwned>::Owned: fmt::Debug,
 {
     /// Debug label of the bind group.
     ///
@@ -545,11 +559,12 @@ pub struct BindGroupDescriptor<
     #[cfg_attr(
         feature = "serde",
         serde(bound(
-            deserialize = "<[BindGroupEntry<'a, B, S, TV, TLAS>] as ToOwned>::Owned: Deserialize<'de>"
+            deserialize = "<[BindGroupEntry<'a, B, S, TV, TLAS, ET>] as ToOwned>::Owned: Deserialize<'de>"
         ))
     )]
     /// The resources to bind to this bind group.
-    pub entries: Cow<'a, [BindGroupEntry<'a, B, S, TV, TLAS>]>,
+    #[allow(clippy::type_complexity)]
+    pub entries: Cow<'a, [BindGroupEntry<'a, B, S, TV, TLAS, ET>]>,
 }
 
 /// cbindgen:ignore
@@ -560,6 +575,7 @@ pub type ResolvedBindGroupDescriptor<'a> = BindGroupDescriptor<
     Arc<Sampler>,
     Arc<TextureView>,
     Arc<Tlas>,
+    Arc<ExternalTexture>,
 >;
 
 /// Describes a [`BindGroupLayout`].
@@ -881,8 +897,14 @@ pub type ResolvedBufferBinding = BufferBinding<Arc<Buffer>>;
 // They're different enough that it doesn't make sense to share a common type
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum BindingResource<'a, B = BufferId, S = SamplerId, TV = TextureViewId, TLAS = TlasId>
-where
+pub enum BindingResource<
+    'a,
+    B = BufferId,
+    S = SamplerId,
+    TV = TextureViewId,
+    TLAS = TlasId,
+    ET = ExternalTextureId,
+> where
     [BufferBinding<B>]: ToOwned,
     [S]: ToOwned,
     [TV]: ToOwned,
@@ -909,10 +931,17 @@ where
     )]
     TextureViewArray(Cow<'a, [TV]>),
     AccelerationStructure(TLAS),
+    ExternalTexture(ET),
 }
 
-pub type ResolvedBindingResource<'a> =
-    BindingResource<'a, Arc<Buffer>, Arc<Sampler>, Arc<TextureView>, Arc<Tlas>>;
+pub type ResolvedBindingResource<'a> = BindingResource<
+    'a,
+    Arc<Buffer>,
+    Arc<Sampler>,
+    Arc<TextureView>,
+    Arc<Tlas>,
+    Arc<ExternalTexture>,
+>;
 
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]

wgpu-core/src/device/global.rs

@@ -802,6 +802,7 @@ impl Global {
                 sampler_storage: &Storage<Fallible<resource::Sampler>>,
                 texture_view_storage: &Storage<Fallible<resource::TextureView>>,
                 tlas_storage: &Storage<Fallible<resource::Tlas>>,
+                external_texture_storage: &Storage<Fallible<resource::ExternalTexture>>,
             ) -> Result<ResolvedBindGroupEntry<'a>, binding_model::CreateBindGroupError>
             {
                 let resolve_buffer = |bb: &BufferBinding| {
@@ -833,6 +834,12 @@ impl Global {
                         .get()
                         .map_err(binding_model::CreateBindGroupError::from)
                 };
+                let resolve_external_texture = |id: &id::ExternalTextureId| {
+                    external_texture_storage
+                        .get(*id)
+                        .get()
+                        .map_err(binding_model::CreateBindGroupError::from)
+                };
                 let resource = match e.resource {
                     BindingResource::Buffer(ref buffer) => {
                         ResolvedBindingResource::Buffer(resolve_buffer(buffer)?)
@@ -867,6 +874,9 @@ impl Global {
                     BindingResource::AccelerationStructure(ref tlas) => {
                         ResolvedBindingResource::AccelerationStructure(resolve_tlas(tlas)?)
                     }
+                    BindingResource::ExternalTexture(ref et) => {
+                        ResolvedBindingResource::ExternalTexture(resolve_external_texture(et)?)
+                    }
                 };
                 Ok(ResolvedBindGroupEntry {
                     binding: e.binding,
@@ -879,6 +889,7 @@ impl Global {
                 let texture_view_guard = hub.texture_views.read();
                 let sampler_guard = hub.samplers.read();
                 let tlas_guard = hub.tlas_s.read();
+                let external_texture_guard = hub.external_textures.read();
                 desc.entries
                     .iter()
                     .map(|e| {
@@ -888,6 +899,7 @@ impl Global {
                             &sampler_guard,
                             &texture_view_guard,
                             &tlas_guard,
+                            &external_texture_guard,
                         )
                     })
                     .collect::<Result<Vec<_>, _>>()