Introduce VertexStep: a stride and a step mode. (#2768)

This is used in various places around render pipelines, passes, and
bundles.

The public `wgpu_core::pipeline::VertexBufferLayout` could use
`VertexStep` as well, but I think it's best to let that continue to
resemble `GPUVertexBufferLayout`.

wgpu-core/src/command/bundle.rs

@@ -376,7 +376,7 @@ impl RenderBundleEncoder {
                     state.pipeline_layout = Some(pipeline.layout_id.value);
 
                     state.set_pipeline(
-                        &pipeline.vertex_strides,
+                        &pipeline.vertex_steps,
                         &layout.bind_group_layout_ids,
                         &layout.push_constant_ranges,
                     );
@@ -996,8 +996,7 @@ impl IndexState {
 struct VertexState {
     buffer: Option<id::BufferId>,
     range: Range<wgt::BufferAddress>,
-    stride: wgt::BufferAddress,
-    rate: wgt::VertexStepMode,
+    step: pipeline::VertexStep,
     is_dirty: bool,
 }
 
@@ -1008,8 +1007,7 @@ impl VertexState {
         Self {
             buffer: None,
             range: 0..0,
-            stride: 0,
-            rate: wgt::VertexStepMode::Vertex,
+            step: pipeline::VertexStep::default(),
             is_dirty: false,
         }
     }
@@ -1149,11 +1147,11 @@ impl<A: HalApi> State<A> {
             instance_limit_slot: 0,
         };
         for (idx, vbs) in self.vertex.iter().enumerate() {
-            if vbs.stride == 0 {
+            if vbs.step.stride == 0 {
                 continue;
             }
-            let limit = ((vbs.range.end - vbs.range.start) / vbs.stride) as u32;
-            match vbs.rate {
+            let limit = ((vbs.range.end - vbs.range.start) / vbs.step.stride) as u32;
+            match vbs.step.mode {
                 wgt::VertexStepMode::Vertex => {
                     if limit < vert_state.vertex_limit {
                         vert_state.vertex_limit = limit;
@@ -1211,13 +1209,12 @@ impl<A: HalApi> State<A> {
 
     fn set_pipeline(
         &mut self,
-        vertex_strides: &[(wgt::BufferAddress, wgt::VertexStepMode)],
+        steps: &[pipeline::VertexStep],
         layout_ids: &[id::Valid<id::BindGroupLayoutId>],
         push_constant_layouts: &[wgt::PushConstantRange],
     ) {
-        for (vs, &(stride, step_mode)) in self.vertex.iter_mut().zip(vertex_strides) {
-            vs.stride = stride;
-            vs.rate = step_mode;
+        for (vs, &step) in self.vertex.iter_mut().zip(steps) {
+            vs.step = step;
         }
 
         let push_constants_changed = self

wgpu-core/src/command/render.rs

@@ -17,7 +17,7 @@ use crate::{
     hub::{Global, GlobalIdentityHandlerFactory, HalApi, Storage, Token},
     id,
     init_tracker::{MemoryInitKind, TextureInitRange, TextureInitTrackerAction},
-    pipeline::PipelineFlags,
+    pipeline::{self, PipelineFlags},
     resource::{self, Buffer, Texture, TextureView},
     track::{TextureSelector, UsageConflict, UsageScope},
     validation::{
@@ -298,16 +298,17 @@ impl IndexState {
 #[derive(Clone, Copy, Debug)]
 struct VertexBufferState {
     total_size: BufferAddress,
-    stride: BufferAddress,
-    rate: VertexStepMode,
+    step: pipeline::VertexStep,
     bound: bool,
 }
 
 impl VertexBufferState {
     const EMPTY: Self = Self {
         total_size: 0,
-        stride: 0,
-        rate: VertexStepMode::Vertex,
+        step: pipeline::VertexStep {
+            stride: 0,
+            mode: VertexStepMode::Vertex,
+        },
         bound: false,
     };
 }
@@ -332,11 +333,11 @@ impl VertexState {
         self.vertex_limit = u32::MAX;
         self.instance_limit = u32::MAX;
         for (idx, vbs) in self.inputs.iter().enumerate() {
-            if vbs.stride == 0 || !vbs.bound {
+            if vbs.step.stride == 0 || !vbs.bound {
                 continue;
             }
-            let limit = (vbs.total_size / vbs.stride) as u32;
-            match vbs.rate {
+            let limit = (vbs.total_size / vbs.step.stride) as u32;
+            match vbs.step.mode {
                 VertexStepMode::Vertex => {
                     if limit < self.vertex_limit {
                         self.vertex_limit = limit;
@@ -1340,24 +1341,25 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
                         state.index.pipeline_format = pipeline.strip_index_format;
 
-                        let vertex_strides_len = pipeline.vertex_strides.len();
-                        state.vertex.buffers_required = vertex_strides_len as u32;
+                        let vertex_steps_len = pipeline.vertex_steps.len();
+                        state.vertex.buffers_required = vertex_steps_len as u32;
 
-                        while state.vertex.inputs.len() < vertex_strides_len {
+                        // Initialize each `vertex.inputs[i].step` from
+                        // `pipeline.vertex_steps[i]`.  Enlarge `vertex.inputs`
+                        // as necessary to accomodate all slots in the
+                        // pipeline. If `vertex.inputs` is longer, fill the
+                        // extra entries with default `VertexStep`s.
+                        while state.vertex.inputs.len() < vertex_steps_len {
                             state.vertex.inputs.push(VertexBufferState::EMPTY);
                         }
 
-                        // Update vertex buffer limits
-                        for (vbs, &(stride, rate)) in
-                            state.vertex.inputs.iter_mut().zip(&pipeline.vertex_strides)
-                        {
-                            vbs.stride = stride;
-                            vbs.rate = rate;
-                        }
-                        for vbs in state.vertex.inputs.iter_mut().skip(vertex_strides_len) {
-                            vbs.stride = 0;
-                            vbs.rate = VertexStepMode::Vertex;
+                        // This is worse as a `zip`, but it's close.
+                        let mut steps = pipeline.vertex_steps.iter();
+                        for input in state.vertex.inputs.iter_mut() {
+                            input.step = steps.next().cloned().unwrap_or_default();
                         }
+
+                        // Update vertex buffer limits.
                         state.vertex.update_limits();
                     }
                     RenderCommand::SetIndexBuffer {

wgpu-core/src/device/mod.rs

@@ -2458,13 +2458,14 @@ impl<A: HalApi> Device<A> {
         let mut io = validation::StageIo::default();
         let mut validated_stages = wgt::ShaderStages::empty();
 
-        let mut vertex_strides = Vec::with_capacity(desc.vertex.buffers.len());
+        let mut vertex_steps = Vec::with_capacity(desc.vertex.buffers.len());
         let mut vertex_buffers = Vec::with_capacity(desc.vertex.buffers.len());
         let mut total_attributes = 0;
         for (i, vb_state) in desc.vertex.buffers.iter().enumerate() {
-            vertex_strides
-                .alloc()
-                .init((vb_state.array_stride, vb_state.step_mode));
+            vertex_steps.alloc().init(pipeline::VertexStep {
+                stride: vb_state.array_stride,
+                mode: vb_state.step_mode,
+            });
             if vb_state.attributes.is_empty() {
                 continue;
             }
@@ -2862,7 +2863,7 @@ impl<A: HalApi> Device<A> {
             pass_context,
             flags,
             strip_index_format: desc.primitive.strip_index_format,
-            vertex_strides,
+            vertex_steps,
             late_sized_buffer_groups,
             life_guard: LifeGuard::new(desc.label.borrow_or_default()),
         };

wgpu-core/src/pipeline.rs

@@ -357,6 +357,25 @@ bitflags::bitflags! {
     }
 }
 
+/// How a render pipeline will retrieve attributes from a particular vertex buffer.
+#[derive(Clone, Copy, Debug)]
+pub struct VertexStep {
+    /// The byte stride in the buffer between one attribute value and the next.
+    pub stride: wgt::BufferAddress,
+
+    /// Whether the buffer is indexed by vertex number or instance number.
+    pub mode: wgt::VertexStepMode,
+}
+
+impl Default for VertexStep {
+    fn default() -> Self {
+        Self {
+            stride: 0,
+            mode: wgt::VertexStepMode::Vertex,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RenderPipeline<A: hal::Api> {
     pub(crate) raw: A::RenderPipeline,
@@ -365,7 +384,7 @@ pub struct RenderPipeline<A: hal::Api> {
     pub(crate) pass_context: RenderPassContext,
     pub(crate) flags: PipelineFlags,
     pub(crate) strip_index_format: Option<wgt::IndexFormat>,
-    pub(crate) vertex_strides: Vec<(wgt::BufferAddress, wgt::VertexStepMode)>,
+    pub(crate) vertex_steps: Vec<VertexStep>,
     pub(crate) late_sized_buffer_groups: ArrayVec<LateSizedBufferGroup, { hal::MAX_BIND_GROUPS }>,
     pub(crate) life_guard: LifeGuard,
 }