[wgpu-core] Create default ExternalTextureParams buffer

In upcoming patches, wgpu will allowing the creation of bind groups
with either `TextureView`s or `ExternalTexture`s bound to a
`BindingType::ExternalTexture` bind group layout entry.

Wgpu-hal and the Naga-generated shaders must be able to handle both of
these cases. For external textures they will be provided a uniform
buffer containing the external texture's `ExternalTextureParams`. For
the texture view case, we must therefore provide the same.

To do this, we create a single buffer per device which can be shared
between all texture views. We initialize it with the required values
in Device::late_init_resources_with_queue(). We know that texture
views must have a single RGBA plane, with no rotation or
crop-rect. The only thing that can vary between them is their size. We
will therefore use the value of [0, 0] in the params buffer to
indicate to the shader that it should query the actual texture's size
rather than using the value provided in the buffer.

Author: jamienicol

wgpu-core/src/device/resource.rs

@@ -173,6 +173,10 @@ pub struct Device {
     // Optional so that we can late-initialize this after the queue is created.
     pub(crate) timestamp_normalizer:
         OnceCellOrLock<crate::timestamp_normalization::TimestampNormalizer>,
+    /// Uniform buffer containing [`ExternalTextureParams`] with values such
+    /// that a [`TextureView`] bound to a [`wgt::BindingType::ExternalTexture`]
+    /// binding point will be rendered correctly.
+    pub(crate) default_external_texture_params_buffer: std::sync::OnceLock<Arc<Buffer>>,
     // needs to be dropped last
     #[cfg(feature = "trace")]
     pub(crate) trace: Mutex<Option<trace::Trace>>,
@@ -314,6 +318,7 @@ impl Device {
             adapter: adapter.clone(),
             queue: OnceCellOrLock::new(),
             zero_buffer: ManuallyDrop::new(zero_buffer),
+            default_external_texture_params_buffer: std::sync::OnceLock::new(),
             label: desc.label.to_string(),
             command_allocator,
             command_indices: RwLock::new(
@@ -364,7 +369,7 @@ impl Device {
         })
     }
 
-    pub fn late_init_resources_with_queue(&self) -> Result<(), RequestDeviceError> {
+    pub fn late_init_resources_with_queue(self: &Arc<Self>) -> Result<(), RequestDeviceError> {
         let queue = self.get_queue().unwrap();
 
         let timestamp_normalizer = crate::timestamp_normalization::TimestampNormalizer::new(
@@ -376,6 +381,50 @@ impl Device {
             .set(timestamp_normalizer)
             .unwrap_or_else(|_| panic!("Called late_init_resources_with_queue twice"));
 
+        let params_data = ExternalTextureParams {
+            #[rustfmt::skip]
+            yuv_conversion_matrix: [
+                1.0, 0.0, 0.0, 0.0,
+                0.0, 1.0, 0.0, 0.0,
+                0.0, 0.0, 1.0, 0.0,
+                0.0, 0.0, 0.0, 1.0,
+            ],
+            size: [0, 0],
+            #[rustfmt::skip]
+            sample_transform: [
+                1.0, 0.0,
+                0.0, 1.0,
+                0.0, 0.0
+            ],
+            num_planes: 1,
+        };
+        let params_buffer = self
+            .create_buffer(&resource::BufferDescriptor {
+                label: Some(Cow::Borrowed(
+                    "(wgpu internal) default external texture params buffer",
+                )),
+                size: size_of_val(&params_data) as wgt::BufferAddress,
+                usage: wgt::BufferUsages::UNIFORM | wgt::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            })
+            .map_err(|err| match err {
+                resource::CreateBufferError::Device(device) => RequestDeviceError::Device(device),
+                _ => unreachable!("Error creating default external texture params buffer: {err:?}"),
+            })?;
+        queue
+            .write_buffer(
+                Fallible::Valid(params_buffer.clone()),
+                0,
+                bytemuck::bytes_of(&params_data),
+            )
+            .map_err(|err| match err {
+                super::queue::QueueWriteError::Queue(device) => RequestDeviceError::Device(device),
+                _ => unreachable!("Error writing default external texture params buffer: {err:?}"),
+            })?;
+        self.default_external_texture_params_buffer
+            .set(params_buffer)
+            .unwrap_or_else(|_| panic!("Called late_init_resources_with_queue twice"));
+
         Ok(())
     }