[naga] Generate special type for external texture params buffer

During wgsl lowering, if we encounter an external texture type then
generate the `ExternalTextureParams` struct. This will be required by
most Naga backends to implement external textures.

This type is not actually used by wgsl-in or the IR. However,
generating it in Naga IR ensures tricky details such as member
alignment are handled for us.

wgsl-out must ensure it does *not* generate code for this type, as it
handles external textures natively.

Author: jamienicol

naga/src/back/wgsl/writer.rs

@@ -115,6 +115,7 @@ impl<W: Write> Writer<W> {
             .predeclared_types
             .values()
             .any(|t| *t == handle)
+            || Some(handle) == module.special_types.external_texture_params
     }
 
     pub fn write(&mut self, module: &Module, info: &valid::ModuleInfo) -> BackendResult {

naga/src/compact/mod.rs

@@ -380,6 +380,7 @@ impl<'module> ModuleTracer<'module> {
             ref ray_intersection,
             ref ray_vertex_return,
             ref predeclared_types,
+            ref external_texture_params,
         } = *special_types;
 
         if let Some(ray_desc) = *ray_desc {
@@ -391,6 +392,9 @@ impl<'module> ModuleTracer<'module> {
         if let Some(ray_vertex_return) = *ray_vertex_return {
             self.types_used.insert(ray_vertex_return);
         }
+        if let Some(external_texture_params) = *external_texture_params {
+            self.types_used.insert(external_texture_params);
+        }
         for (_, &handle) in predeclared_types {
             self.types_used.insert(handle);
         }
@@ -532,6 +536,7 @@ impl ModuleMap {
             ref mut ray_intersection,
             ref mut ray_vertex_return,
             ref mut predeclared_types,
+            ref mut external_texture_params,
         } = *special;
 
         if let Some(ref mut ray_desc) = *ray_desc {
@@ -545,6 +550,10 @@ impl ModuleMap {
             self.types.adjust(ray_vertex_return);
         }
 
+        if let Some(ref mut external_texture_params) = *external_texture_params {
+            self.types.adjust(external_texture_params);
+        }
+
         for handle in predeclared_types.values_mut() {
             self.types.adjust(handle);
         }

naga/src/front/type_gen.rs

@@ -276,6 +276,91 @@ impl crate::Module {
         handle
     }
 
+    pub fn generate_external_texture_params_type(&mut self) -> Handle<crate::Type> {
+        if let Some(handle) = self.special_types.external_texture_params {
+            return handle;
+        }
+
+        let ty_u32 = self.types.insert(
+            crate::Type {
+                name: None,
+                inner: crate::TypeInner::Scalar(crate::Scalar::U32),
+            },
+            Span::UNDEFINED,
+        );
+        let ty_vec2u = self.types.insert(
+            crate::Type {
+                name: None,
+                inner: crate::TypeInner::Vector {
+                    size: crate::VectorSize::Bi,
+                    scalar: crate::Scalar::U32,
+                },
+            },
+            Span::UNDEFINED,
+        );
+        let ty_mat3x2f = self.types.insert(
+            crate::Type {
+                name: None,
+                inner: crate::TypeInner::Matrix {
+                    columns: crate::VectorSize::Tri,
+                    rows: crate::VectorSize::Bi,
+                    scalar: crate::Scalar::F32,
+                },
+            },
+            Span::UNDEFINED,
+        );
+        let ty_mat4x4f = self.types.insert(
+            crate::Type {
+                name: None,
+                inner: crate::TypeInner::Matrix {
+                    columns: crate::VectorSize::Quad,
+                    rows: crate::VectorSize::Quad,
+                    scalar: crate::Scalar::F32,
+                },
+            },
+            Span::UNDEFINED,
+        );
+
+        let handle = self.types.insert(
+            crate::Type {
+                name: Some("NagaExternalTextureParams".to_string()),
+                inner: crate::TypeInner::Struct {
+                    members: vec![
+                        crate::StructMember {
+                            name: Some("yuv_conversion_matrix".to_string()),
+                            ty: ty_mat4x4f,
+                            binding: None,
+                            offset: 0,
+                        },
+                        crate::StructMember {
+                            name: Some("sample_transform".to_string()),
+                            ty: ty_mat3x2f,
+                            binding: None,
+                            offset: 64,
+                        },
+                        crate::StructMember {
+                            name: Some("size".to_string()),
+                            ty: ty_vec2u,
+                            binding: None,
+                            offset: 88,
+                        },
+                        crate::StructMember {
+                            name: Some("num_planes".to_string()),
+                            ty: ty_u32,
+                            binding: None,
+                            offset: 96,
+                        },
+                    ],
+                    span: 112,
+                },
+            },
+            Span::UNDEFINED,
+        );
+
+        self.special_types.external_texture_params = Some(handle);
+        handle
+    }
+
     /// Populate this module's [`SpecialTypes::predeclared_types`] type and return the handle.
     ///
     /// [`SpecialTypes::predeclared_types`]: crate::SpecialTypes::predeclared_types

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

@@ -3950,11 +3950,21 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                 dim,
                 arrayed,
                 class,
-            } => ir::TypeInner::Image {
-                dim,
-                arrayed,
-                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.
+                    ctx.module.generate_external_texture_params_type();
+                }
+                ir::TypeInner::Image {
+                    dim,
+                    arrayed,
+                    class,
+                }
+            }
             ast::Type::Sampler { comparison } => ir::TypeInner::Sampler { comparison },
             ast::Type::AccelerationStructure { vertex_return } => {
                 ir::TypeInner::AccelerationStructure { vertex_return }

naga/src/ir/mod.rs

@@ -2334,6 +2334,13 @@ pub struct SpecialTypes {
     /// Call [`Module::generate_vertex_return_type`]
     pub ray_vertex_return: Option<Handle<Type>>,
 
+    /// Struct containing parameters required by some backends to emit code for
+    /// [`ImageClass::External`] textures.
+    ///
+    /// Call [`Module::generate_external_texture_params_type`] to populate this
+    /// if needed and return the handle.
+    pub external_texture_params: Option<Handle<Type>>,
+
     /// Types for predeclared wgsl types instantiated on demand.
     ///
     /// Call [`Module::generate_predeclared_type`] to populate this if

naga/tests/out/ir/spv-fetch_depth.compact.ron

@@ -67,6 +67,7 @@
         ray_desc: None,
         ray_intersection: None,
         ray_vertex_return: None,
+        external_texture_params: None,
         predeclared_types: {},
     ),
     constants: [

naga/tests/out/ir/spv-fetch_depth.ron

@@ -130,6 +130,7 @@
         ray_desc: None,
         ray_intersection: None,
         ray_vertex_return: None,
+        external_texture_params: None,
         predeclared_types: {},
     ),
     constants: [

naga/tests/out/ir/spv-shadow.compact.ron

@@ -155,6 +155,7 @@
         ray_desc: None,
         ray_intersection: None,
         ray_vertex_return: None,
+        external_texture_params: None,
         predeclared_types: {},
     ),
     constants: [

naga/tests/out/ir/spv-shadow.ron

@@ -278,6 +278,7 @@
         ray_desc: None,
         ray_intersection: None,
         ray_vertex_return: None,
+        external_texture_params: None,
         predeclared_types: {},
     ),
     constants: [

naga/tests/out/ir/spv-spec-constants.compact.ron

@@ -171,6 +171,7 @@
         ray_desc: None,
         ray_intersection: None,
         ray_vertex_return: None,
+        external_texture_params: None,
         predeclared_types: {},
     ),
     constants: [