Bind group entries (#9694)

# Objective

Simplify bind group creation code. alternative to (and based on) #9476

## Solution

- Add a `BindGroupEntries` struct that can transparently be used where
`&[BindGroupEntry<'b>]` is required in BindGroupDescriptors.

Allows constructing the descriptor's entries as:
```rust
render_device.create_bind_group(
    "my_bind_group",
    &my_layout,
    &BindGroupEntries::with_indexes((
        (2, &my_sampler),
        (3, my_uniform),
    )),
);
```

instead of

```rust
render_device.create_bind_group(
    "my_bind_group",
    &my_layout,
    &[
        BindGroupEntry {
            binding: 2,
            resource: BindingResource::Sampler(&my_sampler),
        },
        BindGroupEntry {
            binding: 3,
            resource: my_uniform,
        },
    ],
);
```

or

```rust
render_device.create_bind_group(
    "my_bind_group",
    &my_layout,
    &BindGroupEntries::sequential((&my_sampler, my_uniform)),
);
```

instead of

```rust
render_device.create_bind_group(
    "my_bind_group",
    &my_layout,
    &[
        BindGroupEntry {
            binding: 0,
            resource: BindingResource::Sampler(&my_sampler),
        },
        BindGroupEntry {
            binding: 1,
            resource: my_uniform,
        },
    ],
);
```

the structs has no user facing macros, is tuple-type-based so stack
allocated, and has no noticeable impact on compile time.

- Also adds a `DynamicBindGroupEntries` struct with a similar api that
uses a `Vec` under the hood and allows extending the entries.
- Modifies `RenderDevice::create_bind_group` to take separate arguments
`label`, `layout` and `entries` instead of a `BindGroupDescriptor`
struct. The struct can't be stored due to the internal references, and
with only 3 members arguably does not add enough context to justify
itself.
- Modify the codebase to use the new api and the `BindGroupEntries` /
`DynamicBindGroupEntries` structs where appropriate (whenever the
entries slice contains more than 1 member).

## Migration Guide

- Calls to `RenderDevice::create_bind_group({BindGroupDescriptor {
label, layout, entries })` must be amended to
`RenderDevice::create_bind_group(label, layout, entries)`.
- If `label`s have been specified as `"bind_group_name".into()`, they
need to change to just `"bind_group_name"`. `Some("bind_group_name")`
and `None` will still work, but `Some("bind_group_name")` can optionally
be simplified to just `"bind_group_name"`.

---------

Co-authored-by: IceSentry <[email protected]>

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -170,30 +170,16 @@ impl ViewNode for BloomNode {
 
         // First downsample pass
         {
-            let downsampling_first_bind_group =
-                render_context
-                    .render_device()
-                    .create_bind_group(&BindGroupDescriptor {
-                        label: Some("bloom_downsampling_first_bind_group"),
-                        layout: &downsampling_pipeline_res.bind_group_layout,
-                        entries: &[
-                            BindGroupEntry {
-                                binding: 0,
-                                // Read from main texture directly
-                                resource: BindingResource::TextureView(
-                                    view_target.main_texture_view(),
-                                ),
-                            },
-                            BindGroupEntry {
-                                binding: 1,
-                                resource: BindingResource::Sampler(&bind_groups.sampler),
-                            },
-                            BindGroupEntry {
-                                binding: 2,
-                                resource: uniforms.clone(),
-                            },
-                        ],
-                    });
+            let downsampling_first_bind_group = render_context.render_device().create_bind_group(
+                "bloom_downsampling_first_bind_group",
+                &downsampling_pipeline_res.bind_group_layout,
+                &BindGroupEntries::sequential((
+                    // Read from main texture directly
+                    view_target.main_texture_view(),
+                    &bind_groups.sampler,
+                    uniforms.clone(),
+                )),
+            );
 
             let view = &bloom_texture.view(0);
             let mut downsampling_first_pass =
@@ -416,46 +402,28 @@ fn prepare_bloom_bind_groups(
 
         let mut downsampling_bind_groups = Vec::with_capacity(bind_group_count);
         for mip in 1..bloom_texture.mip_count {
-            downsampling_bind_groups.push(render_device.create_bind_group(&BindGroupDescriptor {
-                label: Some("bloom_downsampling_bind_group"),
-                layout: &downsampling_pipeline.bind_group_layout,
-                entries: &[
-                    BindGroupEntry {
-                        binding: 0,
-                        resource: BindingResource::TextureView(&bloom_texture.view(mip - 1)),
-                    },
-                    BindGroupEntry {
-                        binding: 1,
-                        resource: BindingResource::Sampler(sampler),
-                    },
-                    BindGroupEntry {
-                        binding: 2,
-                        resource: uniforms.binding().unwrap(),
-                    },
-                ],
-            }));
+            downsampling_bind_groups.push(render_device.create_bind_group(
+                "bloom_downsampling_bind_group",
+                &downsampling_pipeline.bind_group_layout,
+                &BindGroupEntries::sequential((
+                    &bloom_texture.view(mip - 1),
+                    sampler,
+                    uniforms.binding().unwrap(),
+                )),
+            ));
         }
 
         let mut upsampling_bind_groups = Vec::with_capacity(bind_group_count);
         for mip in (0..bloom_texture.mip_count).rev() {
-            upsampling_bind_groups.push(render_device.create_bind_group(&BindGroupDescriptor {
-                label: Some("bloom_upsampling_bind_group"),
-                layout: &upsampling_pipeline.bind_group_layout,
-                entries: &[
-                    BindGroupEntry {
-                        binding: 0,
-                        resource: BindingResource::TextureView(&bloom_texture.view(mip)),
-                    },
-                    BindGroupEntry {
-                        binding: 1,
-                        resource: BindingResource::Sampler(sampler),
-                    },
-                    BindGroupEntry {
-                        binding: 2,
-                        resource: uniforms.binding().unwrap(),
-                    },
-                ],
-            }));
+            upsampling_bind_groups.push(render_device.create_bind_group(
+                "bloom_upsampling_bind_group",
+                &upsampling_pipeline.bind_group_layout,
+                &BindGroupEntries::sequential((
+                    &bloom_texture.view(mip),
+                    sampler,
+                    uniforms.binding().unwrap(),
+                )),
+            ));
         }
 
         commands.entity(entity).insert(BloomBindGroups {

crates/bevy_core_pipeline/src/contrast_adaptive_sharpening/node.rs

@@ -7,8 +7,8 @@ use bevy_render::{
     extract_component::{ComponentUniforms, DynamicUniformIndex},
     render_graph::{Node, NodeRunError, RenderGraphContext},
     render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, BufferId, Operations,
-        PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, TextureViewId,
+        BindGroup, BindGroupEntries, BufferId, Operations, PipelineCache,
+        RenderPassColorAttachment, RenderPassDescriptor, TextureViewId,
     },
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
@@ -77,29 +77,15 @@ impl Node for CASNode {
                 bind_group
             }
             cached_bind_group => {
-                let bind_group =
-                    render_context
-                        .render_device()
-                        .create_bind_group(&BindGroupDescriptor {
-                            label: Some("cas_bind_group"),
-                            layout: &sharpening_pipeline.texture_bind_group,
-                            entries: &[
-                                BindGroupEntry {
-                                    binding: 0,
-                                    resource: BindingResource::TextureView(view_target.source),
-                                },
-                                BindGroupEntry {
-                                    binding: 1,
-                                    resource: BindingResource::Sampler(
-                                        &sharpening_pipeline.sampler,
-                                    ),
-                                },
-                                BindGroupEntry {
-                                    binding: 2,
-                                    resource: uniforms,
-                                },
-                            ],
-                        });
+                let bind_group = render_context.render_device().create_bind_group(
+                    "cas_bind_group",
+                    &sharpening_pipeline.texture_bind_group,
+                    &BindGroupEntries::sequential((
+                        view_target.source,
+                        &sharpening_pipeline.sampler,
+                        uniforms,
+                    )),
+                );
 
                 let (_, _, bind_group) =
                     cached_bind_group.insert((uniforms_id, source.id(), bind_group));

crates/bevy_core_pipeline/src/deferred/copy_lighting_id.rs

@@ -18,10 +18,7 @@ use bevy_render::{
 use bevy_ecs::query::QueryItem;
 use bevy_render::{
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    render_resource::{
-        BindGroupDescriptor, BindGroupEntry, BindingResource, Operations, PipelineCache,
-        RenderPassDescriptor,
-    },
+    render_resource::{Operations, PipelineCache, RenderPassDescriptor},
     renderer::RenderContext,
 };
 
@@ -94,18 +91,11 @@ impl ViewNode for CopyDeferredLightingIdNode {
             return Ok(());
         };
 
-        let bind_group = render_context
-            .render_device()
-            .create_bind_group(&BindGroupDescriptor {
-                label: Some("copy_deferred_lighting_id_bind_group"),
-                layout: &copy_deferred_lighting_id_pipeline.layout,
-                entries: &[BindGroupEntry {
-                    binding: 0,
-                    resource: BindingResource::TextureView(
-                        &deferred_lighting_pass_id_texture.default_view,
-                    ),
-                }],
-            });
+        let bind_group = render_context.render_device().create_bind_group(
+            "copy_deferred_lighting_id_bind_group",
+            &copy_deferred_lighting_id_pipeline.layout,
+            &BindGroupEntries::single(&deferred_lighting_pass_id_texture.default_view),
+        );
 
         let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
             label: Some("copy_deferred_lighting_id_pass"),

crates/bevy_core_pipeline/src/fxaa/node.rs

@@ -6,9 +6,8 @@ use bevy_ecs::query::QueryItem;
 use bevy_render::{
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, FilterMode, Operations,
-        PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor,
-        TextureViewId,
+        BindGroup, BindGroupEntries, FilterMode, Operations, PipelineCache,
+        RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor, TextureViewId,
     },
     renderer::RenderContext,
     view::ViewTarget,
@@ -61,23 +60,11 @@ impl ViewNode for FxaaNode {
                         ..default()
                     });
 
-                let bind_group =
-                    render_context
-                        .render_device()
-                        .create_bind_group(&BindGroupDescriptor {
-                            label: None,
-                            layout: &fxaa_pipeline.texture_bind_group,
-                            entries: &[
-                                BindGroupEntry {
-                                    binding: 0,
-                                    resource: BindingResource::TextureView(source),
-                                },
-                                BindGroupEntry {
-                                    binding: 1,
-                                    resource: BindingResource::Sampler(&sampler),
-                                },
-                            ],
-                        });
+                let bind_group = render_context.render_device().create_bind_group(
+                    None,
+                    &fxaa_pipeline.texture_bind_group,
+                    &BindGroupEntries::sequential((source, &sampler)),
+                );
 
                 let (_, bind_group) = cached_bind_group.insert((source.id(), bind_group));
                 bind_group

crates/bevy_core_pipeline/src/msaa_writeback.rs

@@ -8,6 +8,7 @@ use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphApp, RenderGraphContext},
+    render_resource::BindGroupEntries,
     renderer::RenderContext,
     view::{Msaa, ViewTarget},
     Render, RenderSet,
@@ -90,23 +91,11 @@ impl Node for MsaaWritebackNode {
                 depth_stencil_attachment: None,
             };
 
-            let bind_group =
-                render_context
-                    .render_device()
-                    .create_bind_group(&BindGroupDescriptor {
-                        label: None,
-                        layout: &blit_pipeline.texture_bind_group,
-                        entries: &[
-                            BindGroupEntry {
-                                binding: 0,
-                                resource: BindingResource::TextureView(post_process.source),
-                            },
-                            BindGroupEntry {
-                                binding: 1,
-                                resource: BindingResource::Sampler(&blit_pipeline.sampler),
-                            },
-                        ],
-                    });
+            let bind_group = render_context.render_device().create_bind_group(
+                None,
+                &blit_pipeline.texture_bind_group,
+                &BindGroupEntries::sequential((post_process.source, &blit_pipeline.sampler)),
+            );
 
             let mut render_pass = render_context
                 .command_encoder()

crates/bevy_core_pipeline/src/skybox/mod.rs

@@ -10,13 +10,13 @@ use bevy_render::{
     extract_component::{ExtractComponent, ExtractComponentPlugin},
     render_asset::RenderAssets,
     render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
-        BindGroupLayoutEntry, BindingResource, BindingType, BufferBindingType,
-        CachedRenderPipelineId, ColorTargetState, ColorWrites, CompareFunction, DepthBiasState,
-        DepthStencilState, FragmentState, MultisampleState, PipelineCache, PrimitiveState,
-        RenderPipelineDescriptor, SamplerBindingType, Shader, ShaderStages, ShaderType,
-        SpecializedRenderPipeline, SpecializedRenderPipelines, StencilFaceState, StencilState,
-        TextureFormat, TextureSampleType, TextureViewDimension, VertexState,
+        BindGroup, BindGroupEntries, BindGroupLayout, BindGroupLayoutDescriptor,
+        BindGroupLayoutEntry, BindingType, BufferBindingType, CachedRenderPipelineId,
+        ColorTargetState, ColorWrites, CompareFunction, DepthBiasState, DepthStencilState,
+        FragmentState, MultisampleState, PipelineCache, PrimitiveState, RenderPipelineDescriptor,
+        SamplerBindingType, Shader, ShaderStages, ShaderType, SpecializedRenderPipeline,
+        SpecializedRenderPipelines, StencilFaceState, StencilState, TextureFormat,
+        TextureSampleType, TextureViewDimension, VertexState,
     },
     renderer::RenderDevice,
     texture::{BevyDefault, Image},
@@ -224,24 +224,15 @@ fn prepare_skybox_bind_groups(
         if let (Some(skybox), Some(view_uniforms)) =
             (images.get(&skybox.0), view_uniforms.uniforms.binding())
         {
-            let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
-                label: Some("skybox_bind_group"),
-                layout: &pipeline.bind_group_layout,
-                entries: &[
-                    BindGroupEntry {
-                        binding: 0,
-                        resource: BindingResource::TextureView(&skybox.texture_view),
-                    },
-                    BindGroupEntry {
-                        binding: 1,
-                        resource: BindingResource::Sampler(&skybox.sampler),
-                    },
-                    BindGroupEntry {
-                        binding: 2,
-                        resource: view_uniforms,
-                    },
-                ],
-            });
+            let bind_group = render_device.create_bind_group(
+                "skybox_bind_group",
+                &pipeline.bind_group_layout,
+                &BindGroupEntries::sequential((
+                    &skybox.texture_view,
+                    &skybox.sampler,
+                    view_uniforms,
+                )),
+            );
 
             commands.entity(entity).insert(SkyboxBindGroup(bind_group));
         }