fixup! [naga] Generate special type for external texture params buffer

Author: jimblandy

naga/src/back/wgsl/writer.rs

@@ -109,13 +109,28 @@ impl<W: Write> Writer<W> {
         self.required_polyfills.clear();
     }
 
-    fn is_builtin_wgsl_struct(&self, module: &Module, handle: Handle<crate::Type>) -> bool {
+    /// Determine if `ty` is the Naga IR presentation of a WGSL builtin type.
+    ///
+    /// Return true if `ty` refers to the Naga IR form of a WGSL builtin type
+    /// like `__atomic_compare_exchange_result`.
+    ///
+    /// Even though the module may use the type, the WGSL backend should avoid
+    /// emitting a definition for it, since it is [predeclared] in WGSL.
+    ///
+    /// This also covers types like [`NagaExternalTextureParams`], which other
+    /// backends use to lower WGSL constructs like external textures to their
+    /// implementations. WGSL can express these directly, so the types need not
+    /// be emitted.
+    ///
+    /// [predeclared]: https://www.w3.org/TR/WGSL/#predeclared
+    /// [`NagaExternalTextureParams`]: crate::ir::SpecialTypes::external_texture_params
+    fn is_builtin_wgsl_struct(&self, module: &Module, ty: Handle<crate::Type>) -> bool {
         module
             .special_types
             .predeclared_types
             .values()
-            .any(|t| *t == handle)
-            || Some(handle) == module.special_types.external_texture_params
+            .any(|t| *t == ty)
+            || Some(ty) == module.special_types.external_texture_params
     }
 
     pub fn write(&mut self, module: &Module, info: &valid::ModuleInfo) -> BackendResult {

naga/src/front/type_gen.rs

@@ -276,6 +276,9 @@ impl crate::Module {
         handle
     }
 
+    /// Generate [`SpecialTypes::external_texture_params`].
+    ///
+    /// [`SpecialTypes::external_texture_params`]: crate::ir::SpecialTypes::external_texture_params
     pub fn generate_external_texture_params_type(&mut self) -> Handle<crate::Type> {
         if let Some(handle) = self.special_types.external_texture_params {
             return handle;

naga/src/front/wgsl/lower/mod.rs

@@ -3985,11 +3985,19 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                 class,
             } => {
                 if class == crate::ImageClass::External {
-                    // Generate the type for the params buffer that will be
-                    // used by most backends to implement external textures.
-                    // This is *not* the type we are resolving, but the fact we
-                    // are resolving a `texture_external` implies the backends
-                    // will need the params buffer too.
+                    // Other than the WGSL backend, every backend that supports
+                    // external textures does so by lowering them to a set of
+                    // ordinary textures and some parameters saying how to
+                    // sample from them. We don't know which backend will
+                    // consume the `Module` we're building, but in case it's not
+                    // WGSL, populate `SpecialTypes::external_texture_params`
+                    // with the type the backend will use for the parameter
+                    // buffer.
+                    //
+                    // This is *not* the type we are lowering here: that's an
+                    // ordinary `TypeInne::Image`. But the fact we are lowering
+                    // a `texture_external` implies the backends may need
+                    // `SpecialTypes::external_texture_params` too.
                     ctx.module.generate_external_texture_params_type();
                 }
                 ir::TypeInner::Image {

naga/src/ir/mod.rs

@@ -2349,6 +2349,18 @@ pub struct SpecialTypes {
     /// Struct containing parameters required by some backends to emit code for
     /// [`ImageClass::External`] textures.
     ///
+    /// In WGSL, this type would be:
+    ///
+    /// ```ignore
+    /// struct NagaExternalTextureParams {      // align size offset
+    ///     yuv_conversion_matrix: mat4x4<f32>, //    16   64      0
+    ///     sample_transform: mat3x2<f32>,      //     8   24     64
+    ///     load_transform: mat3x2<f32>,        //     8   24     88
+    ///     size: vec2<u32>,                    //     8    8    112
+    ///     num_planes: u32,                    //     4    4    120
+    /// }                         // whole struct:    16  128
+    /// ```
+    ///
     /// Call [`Module::generate_external_texture_params_type`] to populate this
     /// if needed and return the handle.
     pub external_texture_params: Option<Handle<Type>>,