Add a not-yet-working vertex pulling flag to Metal pipelines.

This is an early effort to add infrastructure to support vertex pulling
transformation of Metal shaders. It is *not* a working transformation
that generates valid, useful shaders. It includes:

1) It adds a experimental_vertex_pulling_transform flag to
msl::PipelineOptions. This flag defaults to false but can be forcibly
set to true by naga tests.
2) When the flag is set, generated msl vertex shaders are passed an
additional vertex id parameter, plus an additional parameter for each
bound vertex buffer, plus the _mslBufferSizes struct which is normally
only used for dynamically sized buffers.
3) A new naga test is added which exercises this flag and demonstrates
the effect of the transform.

Future work will make the transformed shaders valid, and add tests that
transformed shaders produce correct results.

naga/CHANGELOG.md

@@ -79,6 +79,7 @@ For changelogs after v0.14, see [the wgpu changelog](../CHANGELOG.md).
 
 - Add and fix minimum Metal version checks for optional functionality. ([#2486](https://github.com/gfx-rs/naga/pull/2486)) **@teoxoy**
 - Make varyings' struct members unique. ([#2521](https://github.com/gfx-rs/naga/pull/2521)) **@evahop**
+- Add experimental vertex pulling transform flag. ([#5254](https://github.com/gfx-rs/wgpu/pull/5254)) **@bradwerth**
 
 #### GLSL-OUT
 

naga/Cargo.toml

@@ -24,7 +24,7 @@ default = []
 dot-out = []
 glsl-in = ["pp-rs"]
 glsl-out = []
-msl-out = []
+msl-out = ["metal"]
 serialize = ["serde", "bitflags/serde", "indexmap/serde"]
 deserialize = ["serde", "bitflags/serde", "indexmap/serde"]
 arbitrary = ["dep:arbitrary", "bitflags/arbitrary", "indexmap/arbitrary"]
@@ -51,6 +51,7 @@ codespan-reporting = { version = "0.11.0" }
 rustc-hash = "1.1.0"
 indexmap = { version = "2", features = ["std"] }
 log = "0.4"
+metal = { version = "0.27.0", git = "https://github.com/gfx-rs/metal-rs", rev = "ff8fd3d6dc7792852f8a015458d7e6d42d7fb352", optional = true }
 num-traits = "0.2"
 spirv = { version = "0.3", optional = true }
 thiserror = "1.0.57"

naga/src/back/msl/mod.rs

@@ -33,6 +33,8 @@ mod keywords;
 pub mod sampler;
 mod writer;
 
+use metal::MTLVertexFormat::*;
+
 pub use writer::Writer;
 
 pub type Slot = u8;
@@ -222,6 +224,208 @@ impl Default for Options {
     }
 }
 
+/// Vertex Format for a [`VertexAttribute`] (input).
+///
+/// Corresponds to [WebGPU `GPUVertexFormat`](
+/// https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat).
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, Default, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+pub enum VertexFormat {
+    #[default]
+    /// Two unsigned bytes (u8). `vec2<u32>` in shaders.
+    Uint8x2 = 0,
+    /// Four unsigned bytes (u8). `vec4<u32>` in shaders.
+    Uint8x4 = 1,
+    /// Two signed bytes (i8). `vec2<i32>` in shaders.
+    Sint8x2 = 2,
+    /// Four signed bytes (i8). `vec4<i32>` in shaders.
+    Sint8x4 = 3,
+    /// Two unsigned bytes (u8). [0, 255] converted to float [0, 1] `vec2<f32>` in shaders.
+    Unorm8x2 = 4,
+    /// Four unsigned bytes (u8). [0, 255] converted to float [0, 1] `vec4<f32>` in shaders.
+    Unorm8x4 = 5,
+    /// Two signed bytes (i8). [-127, 127] converted to float [-1, 1] `vec2<f32>` in shaders.
+    Snorm8x2 = 6,
+    /// Four signed bytes (i8). [-127, 127] converted to float [-1, 1] `vec4<f32>` in shaders.
+    Snorm8x4 = 7,
+    /// Two unsigned shorts (u16). `vec2<u32>` in shaders.
+    Uint16x2 = 8,
+    /// Four unsigned shorts (u16). `vec4<u32>` in shaders.
+    Uint16x4 = 9,
+    /// Two signed shorts (i16). `vec2<i32>` in shaders.
+    Sint16x2 = 10,
+    /// Four signed shorts (i16). `vec4<i32>` in shaders.
+    Sint16x4 = 11,
+    /// Two unsigned shorts (u16). [0, 65535] converted to float [0, 1] `vec2<f32>` in shaders.
+    Unorm16x2 = 12,
+    /// Four unsigned shorts (u16). [0, 65535] converted to float [0, 1] `vec4<f32>` in shaders.
+    Unorm16x4 = 13,
+    /// Two signed shorts (i16). [-32767, 32767] converted to float [-1, 1] `vec2<f32>` in shaders.
+    Snorm16x2 = 14,
+    /// Four signed shorts (i16). [-32767, 32767] converted to float [-1, 1] `vec4<f32>` in shaders.
+    Snorm16x4 = 15,
+    /// Two half-precision floats (no Rust equiv). `vec2<f32>` in shaders.
+    Float16x2 = 16,
+    /// Four half-precision floats (no Rust equiv). `vec4<f32>` in shaders.
+    Float16x4 = 17,
+    /// One single-precision float (f32). `f32` in shaders.
+    Float32 = 18,
+    /// Two single-precision floats (f32). `vec2<f32>` in shaders.
+    Float32x2 = 19,
+    /// Three single-precision floats (f32). `vec3<f32>` in shaders.
+    Float32x3 = 20,
+    /// Four single-precision floats (f32). `vec4<f32>` in shaders.
+    Float32x4 = 21,
+    /// One unsigned int (u32). `u32` in shaders.
+    Uint32 = 22,
+    /// Two unsigned ints (u32). `vec2<u32>` in shaders.
+    Uint32x2 = 23,
+    /// Three unsigned ints (u32). `vec3<u32>` in shaders.
+    Uint32x3 = 24,
+    /// Four unsigned ints (u32). `vec4<u32>` in shaders.
+    Uint32x4 = 25,
+    /// One signed int (i32). `i32` in shaders.
+    Sint32 = 26,
+    /// Two signed ints (i32). `vec2<i32>` in shaders.
+    Sint32x2 = 27,
+    /// Three signed ints (i32). `vec3<i32>` in shaders.
+    Sint32x3 = 28,
+    /// Four signed ints (i32). `vec4<i32>` in shaders.
+    Sint32x4 = 29,
+    /// One double-precision float (f64). `f32` in shaders. Requires [`Features::VERTEX_ATTRIBUTE_64BIT`].
+    Float64 = 30,
+    /// Two double-precision floats (f64). `vec2<f32>` in shaders. Requires [`Features::VERTEX_ATTRIBUTE_64BIT`].
+    Float64x2 = 31,
+    /// Three double-precision floats (f64). `vec3<f32>` in shaders. Requires [`Features::VERTEX_ATTRIBUTE_64BIT`].
+    Float64x3 = 32,
+    /// Four double-precision floats (f64). `vec4<f32>` in shaders. Requires [`Features::VERTEX_ATTRIBUTE_64BIT`].
+    Float64x4 = 33,
+    /// Three unsigned 10-bit integers and one 2-bit integer, packed into a 32-bit integer (u32). [0, 1024] converted to float [0, 1] `vec4<f32>` in shaders.
+    #[cfg_attr(feature = "serde", serde(rename = "unorm10-10-10-2"))]
+    Unorm10_10_10_2 = 34,
+}
+
+impl From<u32> for VertexFormat {
+    fn from(value: u32) -> Self {
+        use VertexFormat::*;
+        match value {
+            0 => Uint8x2,
+            1 => Uint8x4,
+            2 => Sint8x2,
+            3 => Sint8x4,
+            4 => Unorm8x2,
+            5 => Unorm8x4,
+            6 => Snorm8x2,
+            7 => Snorm8x4,
+            8 => Uint16x2,
+            9 => Uint16x4,
+            10 => Sint16x2,
+            11 => Sint16x4,
+            12 => Unorm16x2,
+            13 => Unorm16x4,
+            14 => Snorm16x2,
+            15 => Snorm16x4,
+            16 => Float16x2,
+            17 => Float16x4,
+            18 => Float32,
+            19 => Float32x2,
+            20 => Float32x3,
+            21 => Float32x4,
+            22 => Uint32,
+            23 => Uint32x2,
+            24 => Uint32x3,
+            25 => Uint32x4,
+            26 => Sint32,
+            27 => Sint32x2,
+            28 => Sint32x3,
+            29 => Sint32x4,
+            30 => Float64,
+            31 => Float64x2,
+            32 => Float64x3,
+            33 => Float64x4,
+            34 => Unorm10_10_10_2,
+            _ => panic!("Can't convert value {}", value),
+        }
+    }
+}
+
+impl Into<metal::MTLVertexFormat> for VertexFormat {
+    fn into(self) -> metal::MTLVertexFormat {
+        use VertexFormat::*;
+        match self {
+            Uint8x2 => UChar2,
+            Uint8x4 => UChar4,
+            Sint8x2 => Char2,
+            Sint8x4 => Char4,
+            Unorm8x2 => UChar2Normalized,
+            Unorm8x4 => UChar4Normalized,
+            Snorm8x2 => Char2Normalized,
+            Snorm8x4 => Char4Normalized,
+            Uint16x2 => UShort2,
+            Uint16x4 => UShort4,
+            Sint16x2 => Short2,
+            Sint16x4 => Short4,
+            Unorm16x2 => UShort2Normalized,
+            Unorm16x4 => UShort4Normalized,
+            Snorm16x2 => Short2Normalized,
+            Snorm16x4 => Short4Normalized,
+            Float16x2 => Half2,
+            Float16x4 => Half4,
+            Float32 => Float,
+            Float32x2 => Float2,
+            Float32x3 => Float3,
+            Float32x4 => Float4,
+            Uint32 => UInt,
+            Uint32x2 => UInt2,
+            Uint32x3 => UInt3,
+            Uint32x4 => UInt4,
+            Sint32 => Int,
+            Sint32x2 => Int2,
+            Sint32x3 => Int3,
+            Sint32x4 => Int4,
+            Float64 => unimplemented!(),
+            Float64x2 => unimplemented!(),
+            Float64x3 => unimplemented!(),
+            Float64x4 => unimplemented!(),
+            Unorm10_10_10_2 => UInt1010102Normalized,
+        }
+    }
+}
+
+/// A mapping of vertex buffers and their attributes to shader
+/// locations.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+pub struct AttributeMapping {
+    /// Shader location associated with this attribute
+    pub shader_location: u32,
+    /// Offset in bytes from start of vertex buffer structure
+    pub offset: u32,
+    /// Format code to help us unpack the attribute into the type
+    /// used by the shader. Codes correspond to a 0-based index of
+    /// <https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat>.
+    /// The conversion process is described by
+    /// <https://gpuweb.github.io/gpuweb/#vertex-processing>.
+    pub format: VertexFormat,
+}
+
+/// A description of a vertex buffer with all the information we
+/// need to address the attributes within it.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+pub struct VertexBufferMapping {
+    /// Shader location associated with this buffer
+    pub id: u32,
+    /// Size of the structure in bytes
+    pub stride: u32,
+    /// Vec of the attributes within the structure
+    pub attributes: Vec<AttributeMapping>,
+}
+
 /// A subset of options that are meant to be changed per pipeline.
 #[derive(Debug, Default, Clone)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
@@ -234,6 +438,17 @@ pub struct PipelineOptions {
     ///
     /// Enable this for vertex shaders with point primitive topologies.
     pub allow_and_force_point_size: bool,
+
+    /// Experimental
+    /// If set, when generating the Metal vertex shader, transform it
+    /// to receive the vertex buffers, lengths, and vertex id as args,
+    /// and bounds-check the vertex id and use the index into the
+    /// vertex buffers to access attributes, rather than using Metal's
+    /// [[stage-in]] assembled attribute data.
+    pub experimental_vertex_pulling_transform: bool,
+
+    /// Only used if experimental_vertex_pulling_transform is set.
+    pub vertex_buffer_mappings: Vec<VertexBufferMapping>,
 }
 
 impl Options {