rebased

Author: kurtkuehnert

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -230,106 +230,75 @@ impl Node for BloomNode {
                     });
 
             let view = &bloom_texture.view(0);
-            let mut downsampling_first_pass =
-                render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                    label: Some("bloom_downsampling_first_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations::default(),
-                    })],
-                    depth_stencil_attachment: None,
-                });
-            downsampling_first_pass.set_render_pipeline(downsampling_first_pipeline);
-            downsampling_first_pass.set_bind_group(
-                0,
-                &downsampling_first_bind_group,
-                &[uniform_index.index()],
-            );
-            downsampling_first_pass.draw(0..3, 0..1);
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_downsampling_first_pass")
+                .add_color_attachment(view)
+                .begin()
+                .set_pipeline(downsampling_first_pipeline)
+                .set_bind_group(0, &downsampling_first_bind_group, &[uniform_index.index()])
+                .draw(0..3, 0..1);
         }
 
         // Other downsample passes
         for mip in 1..bloom_texture.mip_count {
+            let down_sampling_bind_group = &bind_groups.downsampling_bind_groups[mip as usize - 1];
             let view = &bloom_texture.view(mip);
-            let mut downsampling_pass =
-                render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                    label: Some("bloom_downsampling_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations::default(),
-                    })],
-                    depth_stencil_attachment: None,
-                });
-            downsampling_pass.set_render_pipeline(downsampling_pipeline);
-            downsampling_pass.set_bind_group(
-                0,
-                &bind_groups.downsampling_bind_groups[mip as usize - 1],
-                &[uniform_index.index()],
-            );
-            downsampling_pass.draw(0..3, 0..1);
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_downsampling_pass")
+                .add_color_attachment(view)
+                .begin()
+                .set_pipeline(downsampling_pipeline)
+                .set_bind_group(0, down_sampling_bind_group, &[uniform_index.index()])
+                .draw(0..3, 0..1);
         }
 
         // Upsample passes except the final one
         for mip in (1..bloom_texture.mip_count).rev() {
-            let view = &bloom_texture.view(mip - 1);
-            let mut upsampling_pass =
-                render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                    label: Some("bloom_upsampling_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations {
-                            load: LoadOp::Load,
-                            store: true,
-                        },
-                    })],
-                    depth_stencil_attachment: None,
-                });
-            upsampling_pass.set_render_pipeline(upsampling_pipeline);
-            upsampling_pass.set_bind_group(
-                0,
-                &bind_groups.upsampling_bind_groups[(bloom_texture.mip_count - mip - 1) as usize],
-                &[uniform_index.index()],
-            );
             let blend = compute_blend_factor(
                 bloom_settings,
                 mip as f32,
                 (bloom_texture.mip_count - 1) as f32,
             );
-            upsampling_pass.set_blend_constant(Color::rgb_linear(blend, blend, blend));
-            upsampling_pass.draw(0..3, 0..1);
+            let upsampling_bind_group =
+                &bind_groups.upsampling_bind_groups[(bloom_texture.mip_count - mip - 1) as usize];
+            let view = &bloom_texture.view(mip - 1);
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_upsampling_pass")
+                .add_color_attachment(view)
+                .set_color_ops(LoadOp::Load, true)
+                .begin()
+                .set_pipeline(upsampling_pipeline)
+                .set_bind_group(0, upsampling_bind_group, &[uniform_index.index()])
+                .set_blend_constant(Color::rgb_linear(blend, blend, blend))
+                .draw(0..3, 0..1);
         }
 
         // Final upsample pass
         // This is very similar to the above upsampling passes with the only difference
         // being the pipeline (which itself is barely different) and the color attachment
         {
-            let mut upsampling_final_pass =
-                render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                    label: Some("bloom_upsampling_final_pass"),
-                    color_attachments: &[Some(view_target.get_unsampled_color_attachment(
-                        Operations {
-                            load: LoadOp::Load,
-                            store: true,
-                        },
-                    ))],
-                    depth_stencil_attachment: None,
-                });
-            upsampling_final_pass.set_render_pipeline(upsampling_final_pipeline);
-            upsampling_final_pass.set_bind_group(
-                0,
-                &bind_groups.upsampling_bind_groups[(bloom_texture.mip_count - 1) as usize],
-                &[uniform_index.index()],
-            );
-            if let Some(viewport) = camera.viewport.as_ref() {
-                upsampling_final_pass.set_camera_viewport(viewport);
-            }
             let blend =
                 compute_blend_factor(bloom_settings, 0.0, (bloom_texture.mip_count - 1) as f32);
-            upsampling_final_pass.set_blend_constant(Color::rgb_linear(blend, blend, blend));
-            upsampling_final_pass.draw(0..3, 0..1);
+            let upsample_final_bind_group =
+                &bind_groups.upsampling_bind_groups[(bloom_texture.mip_count - 1) as usize];
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_upsampling_final_pass")
+                .add_view_target_unsampled(view_target)
+                .set_color_ops(LoadOp::Load, true)
+                .begin()
+                .set_camera_viewport(camera)
+                .set_pipeline(upsampling_final_pipeline)
+                .set_bind_group(0, upsample_final_bind_group, &[uniform_index.index()])
+                .set_blend_constant(Color::rgb_linear(blend, blend, blend))
+                .draw(0..3, 0..1);
         }
 
         render_context.command_encoder().pop_debug_group();

crates/bevy_core_pipeline/src/prepass/node.rs

@@ -2,13 +2,9 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::query::QueryState;
 use bevy_render::{
     camera::ExtractedCamera,
-    prelude::Color,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::RenderPhase,
-    render_resource::{
-        LoadOp, Operations, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
-        RenderPassDescriptor,
-    },
+    render_resource::LoadOp,
     renderer::RenderContext,
     view::{ExtractedView, ViewDepthTexture},
 };
@@ -69,50 +65,37 @@ impl Node for PrepassNode {
             return Ok(());
         };
 
-        let mut color_attachments = vec![];
-        if let Some(view_normals_texture) = &view_prepass_textures.normal {
-            color_attachments.push(Some(RenderPassColorAttachment {
-                view: &view_normals_texture.default_view,
-                resolve_target: None,
-                ops: Operations {
-                    load: LoadOp::Clear(Color::BLACK.into()),
-                    store: true,
-                },
-            }));
-        }
-
         {
             // Set up the pass descriptor with the depth attachment and optional color attachments
-            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                label: Some("prepass"),
-                color_attachments: &color_attachments,
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                    view: &view_depth_texture.view,
-                    depth_ops: Some(Operations {
-                        load: LoadOp::Clear(0.0),
-                        store: true,
-                    }),
-                    stencil_ops: None,
-                }),
-            });
-
-            if let Some(viewport) = camera.viewport.as_ref() {
-                render_pass.set_camera_viewport(viewport);
-            }
+
+            let render_pass = render_context.render_pass(view_entity).set_label("prepass");
+
+            let render_pass = if let Some(view_normals_texture) = &view_prepass_textures.normal {
+                render_pass.add_color_attachment(&view_normals_texture.default_view)
+            } else {
+                render_pass
+            };
+
+            let mut render_pass = render_pass
+                .set_depth_stencil_attachment(&view_depth_texture.view)
+                .set_depth_ops(LoadOp::Clear(0.0), true)
+                .begin();
+
+            render_pass.set_camera_viewport(camera);
 
             // Always run opaque pass to ensure screen is cleared
             {
                 // Run the prepass, sorted front-to-back
                 #[cfg(feature = "trace")]
                 let _opaque_prepass_span = info_span!("opaque_prepass").entered();
-                opaque_prepass_phase.render(&mut render_pass, world, view_entity);
+                render_pass.render_phase(opaque_prepass_phase, world);
             }
 
             if !alpha_mask_prepass_phase.items.is_empty() {
                 // Run the prepass, sorted front-to-back
                 #[cfg(feature = "trace")]
                 let _alpha_mask_prepass_span = info_span!("alpha_mask_prepass").entered();
-                alpha_mask_prepass_phase.render(&mut render_pass, world, view_entity);
+                render_pass.render_phase(opaque_prepass_phase, world);
             }
         }
 

crates/bevy_render/src/render_resource/mod.rs

@@ -28,15 +28,15 @@ pub use wgpu::{
     util::BufferInitDescriptor, AdapterInfo as WgpuAdapterInfo, AddressMode, BindGroupDescriptor,
     BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BindingType,
     BlendComponent, BlendFactor, BlendOperation, BlendState, BufferAddress, BufferBinding,
-    BufferBindingType, BufferDescriptor, BufferSize, BufferUsages, ColorTargetState, ColorWrites,
-    CommandEncoder, CommandEncoderDescriptor, CompareFunction, ComputePass, ComputePassDescriptor,
-    ComputePipelineDescriptor as RawComputePipelineDescriptor, DepthBiasState, DepthStencilState,
-    Extent3d, Face, Features as WgpuFeatures, FilterMode, FragmentState as RawFragmentState,
-    FrontFace, ImageCopyBuffer, ImageCopyBufferBase, ImageCopyTexture, ImageCopyTextureBase,
-    ImageDataLayout, ImageSubresourceRange, IndexFormat, Limits as WgpuLimits, LoadOp, MapMode,
-    MultisampleState, Operations, Origin3d, PipelineLayout, PipelineLayoutDescriptor, PolygonMode,
-    PrimitiveState, PrimitiveTopology, PushConstantRange, RenderPassColorAttachment,
-    RenderPassDepthStencilAttachment, RenderPassDescriptor,
+    BufferBindingType, BufferDescriptor, BufferSize, BufferUsages, Color as RawColor,
+    ColorTargetState, ColorWrites, CommandEncoder, CommandEncoderDescriptor, CompareFunction,
+    ComputePass, ComputePassDescriptor, ComputePipelineDescriptor as RawComputePipelineDescriptor,
+    DepthBiasState, DepthStencilState, Extent3d, Face, Features as WgpuFeatures, FilterMode,
+    FragmentState as RawFragmentState, FrontFace, ImageCopyBuffer, ImageCopyBufferBase,
+    ImageCopyTexture, ImageCopyTextureBase, ImageDataLayout, ImageSubresourceRange, IndexFormat,
+    Limits as WgpuLimits, LoadOp, MapMode, MultisampleState, Operations, Origin3d, PipelineLayout,
+    PipelineLayoutDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology, PushConstantRange,
+    RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor,
     RenderPipelineDescriptor as RawRenderPipelineDescriptor, SamplerBindingType, SamplerDescriptor,
     ShaderModule, ShaderModuleDescriptor, ShaderSource, ShaderStages, StencilFaceState,
     StencilOperation, StencilState, StorageTextureAccess, TextureAspect, TextureDescriptor,