[naga] Reserve names for each plane and params buffer of external texture

Adds new `NameKey` variants `ExternalTextureGlobalVariable` and
`ExternalTextureFunctionArgument`, like their non-external-texture
cousins but additionally keyed by either being a specific plane index
or params buffer.

For each external texture global variable or function argument reserve
additional names for 3 planes and the params buffer. For Naga backends
which must represent external textures as multiple variables/arguments,
this will allow them to uniquely name each one.

Author: jamienicol

naga/src/back/mod.rs

@@ -196,6 +196,31 @@ impl FunctionCtx<'_> {
         }
     }
 
+    /// Helper method that generates a [`NameKey`](crate::proc::NameKey) for an external texture
+    /// function argument.
+    ///
+    /// # Panics
+    /// - If the function arguments are less or equal to `arg`
+    /// - If `self.ty` is not `FunctionType::Function`.
+    pub const fn external_texture_argument_key(
+        &self,
+        arg: u32,
+        external_texture_key: crate::proc::ExternalTextureNameKey,
+    ) -> crate::proc::NameKey {
+        match self.ty {
+            FunctionType::Function(handle) => {
+                crate::proc::NameKey::ExternalTextureFunctionArgument(
+                    handle,
+                    arg,
+                    external_texture_key,
+                )
+            }
+            FunctionType::EntryPoint(_) => {
+                panic!("External textures cannot be used as arguments to entry points")
+            }
+        }
+    }
+
     /// Returns true if the given expression points to a fixed-function pipeline input.
     pub fn is_fixed_function_input(
         &self,

naga/src/proc/mod.rs

@@ -18,7 +18,7 @@ pub use constant_evaluator::{
 pub use emitter::Emitter;
 pub use index::{BoundsCheckPolicies, BoundsCheckPolicy, IndexableLength, IndexableLengthError};
 pub use layouter::{Alignment, LayoutError, LayoutErrorInner, Layouter, TypeLayout};
-pub use namer::{EntryPointIndex, NameKey, Namer};
+pub use namer::{EntryPointIndex, ExternalTextureNameKey, NameKey, Namer};
 pub use overloads::{Conclusion, MissingSpecialType, OverloadSet, Rule};
 pub use terminator::ensure_block_returns;
 use thiserror::Error;

naga/src/proc/namer.rs

@@ -15,6 +15,40 @@ use crate::{arena::Handle, FastHashMap, FastHashSet};
 pub type EntryPointIndex = u16;
 const SEPARATOR: char = '_';
 
+/// A component of a lowered external texture.
+///
+/// Whereas the WGSL backend implements [`ImageClass::External`]
+/// images directly, most other Naga backends lower them to a
+/// collection of ordinary textures that represent individual planes
+/// (as received from a video decoder, perhaps), together with a
+/// struct of parameters saying how they should be cropped, sampled,
+/// and color-converted.
+///
+/// This lowering means that individual globals and function
+/// parameters in Naga IR must be split out by the backends into
+/// collections of globals and parameters of simpler types.
+///
+/// A value of this enum serves as a name key for one specific
+/// component in the lowered representation of an external texture.
+/// That is, these keys are for variables/parameters that do not exist
+/// in the Naga IR, only in its lowered form.
+///
+/// [`ImageClass::External`]: crate::ir::ImageClass::External
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum ExternalTextureNameKey {
+    Plane(usize),
+    Params,
+}
+
+impl ExternalTextureNameKey {
+    const ALL: &[(&str, ExternalTextureNameKey)] = &[
+        ("_plane0", ExternalTextureNameKey::Plane(0)),
+        ("_plane1", ExternalTextureNameKey::Plane(1)),
+        ("_plane2", ExternalTextureNameKey::Plane(2)),
+        ("_params", ExternalTextureNameKey::Params),
+    ];
+}
+
 #[derive(Debug, Eq, Hash, PartialEq)]
 pub enum NameKey {
     Constant(Handle<crate::Constant>),
@@ -37,6 +71,17 @@ pub enum NameKey {
 
     /// Entry point version of `FunctionOobLocal`.
     EntryPointOobLocal(EntryPointIndex, Handle<crate::Type>),
+
+    /// A global variable holding a component of a lowered external texture.
+    ///
+    /// See [`ExternalTextureNameKey`] for details.
+    ExternalTextureGlobalVariable(Handle<crate::GlobalVariable>, ExternalTextureNameKey),
+
+    /// A function argument holding a component of a lowered external
+    /// texture.
+    ///
+    /// See [`ExternalTextureNameKey`] for details.
+    ExternalTextureFunctionArgument(Handle<crate::Function>, u32, ExternalTextureNameKey),
 }
 
 /// This processor assigns names to all the things in a module
@@ -272,6 +317,27 @@ impl Namer {
             for (index, arg) in fun.arguments.iter().enumerate() {
                 let name = self.call_or(&arg.name, "param");
                 output.insert(NameKey::FunctionArgument(fun_handle, index as u32), name);
+
+                if matches!(
+                    module.types[arg.ty].inner,
+                    crate::TypeInner::Image {
+                        class: crate::ImageClass::External,
+                        ..
+                    }
+                ) {
+                    let base = arg.name.as_deref().unwrap_or("param");
+                    for &(suffix, ext_key) in ExternalTextureNameKey::ALL {
+                        let name = self.call(&format!("{base}_{suffix}"));
+                        output.insert(
+                            NameKey::ExternalTextureFunctionArgument(
+                                fun_handle,
+                                index as u32,
+                                ext_key,
+                            ),
+                            name,
+                        );
+                    }
+                }
             }
             for (handle, var) in fun.local_variables.iter() {
                 let name = self.call_or(&var.name, "local");
@@ -282,6 +348,23 @@ impl Namer {
         for (handle, var) in module.global_variables.iter() {
             let name = self.call_or(&var.name, "global");
             output.insert(NameKey::GlobalVariable(handle), name);
+
+            if matches!(
+                module.types[var.ty].inner,
+                crate::TypeInner::Image {
+                    class: crate::ImageClass::External,
+                    ..
+                }
+            ) {
+                let base = var.name.as_deref().unwrap_or("global");
+                for &(suffix, ext_key) in ExternalTextureNameKey::ALL {
+                    let name = self.call(&format!("{base}_{suffix}"));
+                    output.insert(
+                        NameKey::ExternalTextureGlobalVariable(handle, ext_key),
+                        name,
+                    );
+                }
+            }
         }
 
         for (handle, constant) in module.constants.iter() {