use entries in a few places

Author: IceSentry

crates/bevy_core_pipeline/src/bloom/downsampling_pipeline.rs

@@ -41,42 +41,20 @@ impl FromWorld for BloomDownsamplingPipeline {
     fn from_world(world: &mut World) -> Self {
         let render_device = world.resource::<RenderDevice>();
 
-        // Input texture binding
-        let texture = BindGroupLayoutEntry {
-            binding: 0,
-            ty: BindingType::Texture {
-                sample_type: TextureSampleType::Float { filterable: true },
-                view_dimension: TextureViewDimension::D2,
-                multisampled: false,
-            },
-            visibility: ShaderStages::FRAGMENT,
-            count: None,
-        };
-
-        // Sampler binding
-        let sampler = BindGroupLayoutEntry {
-            binding: 1,
-            ty: BindingType::Sampler(SamplerBindingType::Filtering),
-            visibility: ShaderStages::FRAGMENT,
-            count: None,
-        };
-
-        // Downsampling settings binding
-        let settings = BindGroupLayoutEntry {
-            binding: 2,
-            ty: BindingType::Buffer {
-                ty: BufferBindingType::Uniform,
-                has_dynamic_offset: true,
-                min_binding_size: Some(BloomUniforms::min_size()),
-            },
-            visibility: ShaderStages::FRAGMENT,
-            count: None,
-        };
-
         // Bind group layout
         let bind_group_layout = render_device.create_bind_group_layout(
-            Some("bloom_downsampling_bind_group_layout_with_settings"),
-            &[texture, sampler, settings],
+            "bloom_downsampling_bind_group_layout_with_settings",
+            &BindGroupLayoutEntries::sequential(
+                ShaderStages::FRAGMENT,
+                (
+                    // Input texture binding
+                    texture_2d(TextureSampleType::Float { filterable: true }),
+                    // Sampler binding
+                    sampler(SamplerBindingType::Filtering),
+                    // Downsampling settings binding
+                    uniform_buffer(true, Some(BloomUniforms::min_size())),
+                ),
+            ),
         );
 
         // Sampler

crates/bevy_core_pipeline/src/bloom/upsampling_pipeline.rs

@@ -33,37 +33,17 @@ impl FromWorld for BloomUpsamplingPipeline {
 
         let bind_group_layout = render_device.create_bind_group_layout(
             "bloom_upsampling_bind_group_layout",
-            &[
-                // Input texture
-                BindGroupLayoutEntry {
-                    binding: 0,
-                    ty: BindingType::Texture {
-                        sample_type: TextureSampleType::Float { filterable: true },
-                        view_dimension: TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    visibility: ShaderStages::FRAGMENT,
-                    count: None,
-                },
-                // Sampler
-                BindGroupLayoutEntry {
-                    binding: 1,
-                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
-                    visibility: ShaderStages::FRAGMENT,
-                    count: None,
-                },
-                // BloomUniforms
-                BindGroupLayoutEntry {
-                    binding: 2,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Uniform,
-                        has_dynamic_offset: true,
-                        min_binding_size: Some(BloomUniforms::min_size()),
-                    },
-                    visibility: ShaderStages::FRAGMENT,
-                    count: None,
-                },
-            ],
+            &BindGroupLayoutEntries::sequential(
+                ShaderStages::FRAGMENT,
+                (
+                    // Input texture
+                    texture_2d(TextureSampleType::Float { filterable: true }),
+                    // Sampler
+                    sampler(SamplerBindingType::Filtering),
+                    // BloomUniforms
+                    uniform_buffer(true, Some(BloomUniforms::min_size())),
+                ),
+            ),
         );
 
         BloomUpsamplingPipeline { bind_group_layout }

examples/shader/post_processing.rs

@@ -19,14 +19,7 @@ use bevy::{
         render_graph::{
             NodeRunError, RenderGraphApp, RenderGraphContext, ViewNode, ViewNodeRunner,
         },
-        render_resource::{
-            BindGroupEntries, BindGroupLayout, BindGroupLayoutDescriptor, BindGroupLayoutEntry,
-            BindingType, CachedRenderPipelineId, ColorTargetState, ColorWrites, FragmentState,
-            MultisampleState, Operations, PipelineCache, PrimitiveState, RenderPassColorAttachment,
-            RenderPassDescriptor, RenderPipelineDescriptor, Sampler, SamplerBindingType,
-            SamplerDescriptor, ShaderStages, ShaderType, TextureFormat, TextureSampleType,
-            TextureViewDimension,
-        },
+        render_resource::*,
         renderer::{RenderContext, RenderDevice},
         texture::BevyDefault,
         view::ViewTarget,
@@ -226,40 +219,21 @@ impl FromWorld for PostProcessPipeline {
         let render_device = world.resource::<RenderDevice>();
 
         // We need to define the bind group layout used for our pipeline
-        let layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            label: Some("post_process_bind_group_layout"),
-            entries: &[
-                // The screen texture
-                BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
-                        sample_type: TextureSampleType::Float { filterable: true },
-                        view_dimension: TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                // The sampler that will be used to sample the screen texture
-                BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
-                    count: None,
-                },
-                // The settings uniform that will control the effect
-                BindGroupLayoutEntry {
-                    binding: 2,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: bevy::render::render_resource::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: Some(PostProcessSettings::min_size()),
-                    },
-                    count: None,
-                },
-            ],
-        });
+        let layout = render_device.create_bind_group_layout(
+            "post_process_bind_group_layout",
+            &BindGroupLayoutEntries::sequential(
+                // The layout entries will only be visible in the fragment stage
+                ShaderStages::FRAGMENT,
+                (
+                    // The screen texture
+                    texture_2d(TextureSampleType::Float { filterable: true }),
+                    // The sampler that will be used to sample the screen texture
+                    sampler(SamplerBindingType::Filtering),
+                    // The settings uniform that will control the effect
+                    uniform_buffer(false, Some(PostProcessSettings::min_size())),
+                ),
+            ),
+        );
 
         // We can create the sampler here since it won't change at runtime and doesn't depend on the view
         let sampler = render_device.create_sampler(&SamplerDescriptor::default());