[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,14 @@ use crate::{arena::Handle, FastHashMap, FastHashSet};
 pub type EntryPointIndex = u16;
 const SEPARATOR: char = '_';
 
+/// Some backends may represent an external texture as multiple global variables
+/// or function arguments. This serves as a key for each of those parts.
+#[derive(Debug, Eq, Hash, PartialEq)]
+pub enum ExternalTextureNameKey {
+    Plane(usize),
+    Params,
+}
+
 #[derive(Debug, Eq, Hash, PartialEq)]
 pub enum NameKey {
     Constant(Handle<crate::Constant>),
@@ -37,6 +45,9 @@ pub enum NameKey {
 
     /// Entry point version of `FunctionOobLocal`.
     EntryPointOobLocal(EntryPointIndex, Handle<crate::Type>),
+
+    ExternalTextureGlobalVariable(Handle<crate::GlobalVariable>, ExternalTextureNameKey),
+    ExternalTextureFunctionArgument(Handle<crate::Function>, u32, ExternalTextureNameKey),
 }
 
 /// This processor assigns names to all the things in a module
@@ -272,6 +283,36 @@ 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_ref().map_or("param", |s| s.as_str());
+                    for i in 0..3 {
+                        let name = self.call(&format!("{base}_plane{i}"));
+                        output.insert(
+                            NameKey::ExternalTextureFunctionArgument(
+                                fun_handle,
+                                index as u32,
+                                ExternalTextureNameKey::Plane(i),
+                            ),
+                            name,
+                        );
+                    }
+                    let name = self.call(&format!("{base}_params"));
+                    output.insert(
+                        NameKey::ExternalTextureFunctionArgument(
+                            fun_handle,
+                            index as u32,
+                            ExternalTextureNameKey::Params,
+                        ),
+                        name,
+                    );
+                }
             }
             for (handle, var) in fun.local_variables.iter() {
                 let name = self.call_or(&var.name, "local");
@@ -282,6 +323,31 @@ 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_ref().map_or("global", |s| s.as_str());
+                for i in 0..3 {
+                    let name = self.call(&format!("{base}_plane{i}"));
+                    output.insert(
+                        NameKey::ExternalTextureGlobalVariable(
+                            handle,
+                            ExternalTextureNameKey::Plane(i),
+                        ),
+                        name,
+                    );
+                }
+                let name = self.call(&format!("{base}_params"));
+                output.insert(
+                    NameKey::ExternalTextureGlobalVariable(handle, ExternalTextureNameKey::Params),
+                    name,
+                );
+            }
         }
 
         for (handle, constant) in module.constants.iter() {