Merge pull request #1 from robtfm/render-reorder

Render reorder

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -68,10 +68,10 @@ impl Plugin for BloomPlugin {
             .add_systems(
                 Render,
                 (
-                    prepare_bloom_textures.in_set(RenderSet::ManageViews),
                     prepare_downsampling_pipeline.in_set(RenderSet::Prepare),
                     prepare_upsampling_pipeline.in_set(RenderSet::Prepare),
-                    prepare_bloom_bind_groups.in_set(RenderSet::Prepare),
+                    prepare_bloom_textures.in_set(RenderSet::PrepareBuffers),
+                    prepare_bloom_bind_groups.in_set(RenderSet::PrepareBindgroups),
                 ),
             )
             // Add bloom to the 3d render graph

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -87,17 +87,13 @@ impl Plugin for Core3dPlugin {
             .add_systems(
                 Render,
                 (
-                    prepare_core_3d_depth_textures
-                        .in_set(RenderSet::ManageViews)
-                        .after(bevy_render::view::prepare_windows),
-                    prepare_prepass_textures
-                        .in_set(RenderSet::ManageViews)
-                        .after(bevy_render::view::prepare_windows),
                     sort_phase_system::<Opaque3d>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<AlphaMask3d>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<Transparent3d>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<Opaque3dPrepass>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<AlphaMask3dPrepass>.in_set(RenderSet::PhaseSort),
+                    prepare_core_3d_depth_textures.in_set(RenderSet::PrepareBuffers),
+                    prepare_prepass_textures.in_set(RenderSet::PrepareBuffers),
                 ),
             );
 

crates/bevy_core_pipeline/src/skybox/mod.rs

@@ -47,7 +47,7 @@ impl Plugin for SkyboxPlugin {
                 Render,
                 (
                     prepare_skybox_pipelines.in_set(RenderSet::Prepare),
-                    prepare_skybox_bind_groups.in_set(RenderSet::Prepare),
+                    prepare_skybox_bind_groups.in_set(RenderSet::PrepareBindgroups),
                 ),
             );
     }

crates/bevy_core_pipeline/src/taa/mod.rs

@@ -10,7 +10,7 @@ use bevy_core::FrameCount;
 use bevy_ecs::{
     prelude::{Bundle, Component, Entity},
     query::{QueryItem, With},
-    schedule::{apply_deferred, IntoSystemConfigs},
+    schedule::IntoSystemConfigs,
     system::{Commands, Query, Res, ResMut, Resource},
     world::{FromWorld, World},
 };
@@ -31,7 +31,7 @@ use bevy_render::{
     },
     renderer::{RenderContext, RenderDevice},
     texture::{BevyDefault, CachedTexture, TextureCache},
-    view::{prepare_view_uniforms, ExtractedView, Msaa, ViewTarget},
+    view::{ExtractedView, Msaa, ViewTarget},
     ExtractSchedule, MainWorld, Render, RenderApp, RenderSet,
 };
 
@@ -65,12 +65,9 @@ impl Plugin for TemporalAntiAliasPlugin {
             .add_systems(
                 Render,
                 (
-                    (prepare_taa_jitter_and_mip_bias, apply_deferred)
-                        .chain()
-                        .before(prepare_view_uniforms)
-                        .in_set(RenderSet::Prepare),
-                    prepare_taa_history_textures.in_set(RenderSet::ManageViews),
+                    prepare_taa_jitter_and_mip_bias.in_set(RenderSet::ManageViews),
                     prepare_taa_pipelines.in_set(RenderSet::Prepare),
+                    prepare_taa_history_textures.in_set(RenderSet::PrepareBuffers),
                 ),
             )
             .add_render_graph_node::<ViewNodeRunner<TAANode>>(CORE_3D, draw_3d_graph::node::TAA)

crates/bevy_gizmos/src/lib.rs

@@ -102,7 +102,7 @@ impl Plugin for GizmoPlugin {
             .add_systems(ExtractSchedule, extract_gizmo_data)
             .add_systems(
                 Render,
-                prepare_line_gizmo_bind_group.in_set(RenderSet::Prepare),
+                prepare_line_gizmo_bind_group.in_set(RenderSet::PrepareBindgroups),
             );
 
         #[cfg(feature = "bevy_sprite")]

crates/bevy_gizmos/src/pipeline_2d.rs

@@ -13,7 +13,7 @@ use bevy_ecs::{
     world::{FromWorld, World},
 };
 use bevy_render::{
-    render_asset::RenderAssets,
+    render_asset::{RenderAssets, prepare_assets},
     render_phase::{AddRenderCommand, DrawFunctions, RenderPhase, SetItemPipeline},
     render_resource::*,
     texture::BevyDefault,
@@ -32,7 +32,7 @@ impl Plugin for LineGizmo2dPlugin {
         render_app
             .add_render_command::<Transparent2d, DrawLineGizmo2d>()
             .init_resource::<SpecializedRenderPipelines<LineGizmoPipeline>>()
-            .add_systems(Render, queue_line_gizmos_2d.in_set(RenderSet::Queue));
+            .add_systems(Render, queue_line_gizmos_2d.in_set(RenderSet::Queue).after(prepare_assets::<LineGizmo>));
     }
 
     fn finish(&self, app: &mut App) {

crates/bevy_gizmos/src/pipeline_3d.rs

@@ -14,7 +14,7 @@ use bevy_ecs::{
 };
 use bevy_pbr::{MeshPipeline, MeshPipelineKey, SetMeshViewBindGroup};
 use bevy_render::{
-    render_asset::RenderAssets,
+    render_asset::{RenderAssets, prepare_assets},
     render_phase::{AddRenderCommand, DrawFunctions, RenderPhase, SetItemPipeline},
     render_resource::*,
     texture::BevyDefault,
@@ -30,7 +30,7 @@ impl Plugin for LineGizmo3dPlugin {
         render_app
             .add_render_command::<Transparent3d, DrawLineGizmo3d>()
             .init_resource::<SpecializedRenderPipelines<LineGizmoPipeline>>()
-            .add_systems(Render, queue_line_gizmos_3d.in_set(RenderSet::Queue));
+            .add_systems(Render, queue_line_gizmos_3d.in_set(RenderSet::Queue).after(prepare_assets::<LineGizmo>));
     }
 
     fn finish(&self, app: &mut App) {

crates/bevy_pbr/src/lib.rs

@@ -62,8 +62,8 @@ use bevy_render::{
     render_graph::RenderGraph,
     render_phase::sort_phase_system,
     render_resource::Shader,
-    view::{ViewSet, VisibilitySystems},
-    ExtractSchedule, Render, RenderApp, RenderSet,
+    view::VisibilitySystems,
+    ExtractSchedule, Render, RenderApp, RenderSet, render_asset::prepare_assets, texture::Image,
 };
 use bevy_transform::TransformSystem;
 use environment_map::EnvironmentMapPlugin;
@@ -269,43 +269,19 @@ impl Plugin for PbrPlugin {
 
         // Extract the required data from the main world
         render_app
-            .configure_sets(
-                Render,
-                (
-                    RenderLightSystems::PrepareLights.in_set(RenderSet::ManageViews),
-                    RenderLightSystems::PrepareClusters.in_set(RenderSet::ManageViews),
-                    RenderLightSystems::QueueShadows.in_set(RenderSet::QueueMeshes),
-                ),
-            )
             .add_systems(
                 ExtractSchedule,
                 (
-                    render::extract_clusters.in_set(RenderLightSystems::ExtractClusters),
-                    render::extract_lights.in_set(RenderLightSystems::ExtractLights),
+                    render::extract_clusters,
+                    render::extract_lights,
                 ),
             )
             .add_systems(
                 Render,
                 (
-                    render::prepare_lights
-                        .before(ViewSet::PrepareUniforms)
-                        .in_set(RenderLightSystems::PrepareLights),
-                    // A sync is needed after prepare_lights, before prepare_view_uniforms,
-                    // because prepare_lights creates new views for shadow mapping
-                    apply_deferred
-                        .in_set(RenderSet::Prepare)
-                        .after(RenderLightSystems::PrepareLights)
-                        .before(ViewSet::PrepareUniforms),
-                    render::prepare_clusters
-                        .after(render::prepare_lights)
-                        .in_set(ViewSet::PrepareUniforms),
-                    // A sync is needed after prepare_clusters, before prepare_mesh_view_bind_groups,
-                    // because prepare_clusters inserts ViewClusterBindings on views
-                    apply_deferred
-                        .in_set(RenderSet::Prepare)
-                        .after(render::prepare_clusters)
-                        .before(prepare_mesh_view_bind_groups),
+                    render::prepare_lights.in_set(RenderSet::ManageViews).after(prepare_assets::<Image>),
                     sort_phase_system::<Shadow>.in_set(RenderSet::PhaseSort),
+                    render::prepare_clusters.in_set(RenderSet::PrepareBuffers),
                 ),
             )
             .init_resource::<LightMeta>();

crates/bevy_pbr/src/material.rs

@@ -1,6 +1,6 @@
 use crate::{
     render, AlphaMode, DrawMesh, DrawPrepass, EnvironmentMapLight, MeshPipeline, MeshPipelineKey,
-    MeshTransforms, PrepassPipelinePlugin, PrepassPlugin, RenderLightSystems,
+    MeshTransforms, PrepassPipelinePlugin, PrepassPlugin, 
     ScreenSpaceAmbientOcclusionSettings, SetMeshBindGroup, SetMeshViewBindGroup, Shadow,
 };
 use bevy_app::{App, Plugin};
@@ -24,7 +24,7 @@ use bevy_render::{
     extract_component::ExtractComponentPlugin,
     mesh::{Mesh, MeshVertexBufferLayout},
     prelude::Image,
-    render_asset::{PrepareAssetSet, RenderAssets},
+    render_asset::{RenderAssets, prepare_assets},
     render_phase::{
         AddRenderCommand, DrawFunctions, PhaseItem, RenderCommand, RenderCommandResult,
         RenderPhase, SetItemPipeline, TrackedRenderPass,
@@ -204,11 +204,9 @@ where
                 .add_systems(
                     Render,
                     (
-                        prepare_materials::<M>
-                            .in_set(RenderSet::Prepare)
-                            .after(PrepareAssetSet::PreAssetPrepare),
-                        render::queue_shadows::<M>.in_set(RenderLightSystems::QueueShadows),
-                        queue_material_meshes::<M>.in_set(RenderSet::QueueMeshes),
+                        prepare_materials::<M>.in_set(RenderSet::PrepareAssets).after(prepare_assets::<Image>),
+                        render::queue_shadows::<M>.in_set(RenderSet::QueueMeshes).after(prepare_materials::<M>),
+                        queue_material_meshes::<M>.in_set(RenderSet::QueueMeshes).after(prepare_materials::<M>),
                     ),
                 );
         }

crates/bevy_pbr/src/prepass/mod.rs

@@ -45,9 +45,9 @@ use bevy_transform::prelude::GlobalTransform;
 use bevy_utils::tracing::error;
 
 use crate::{
-    prepare_lights, setup_morph_and_skinning_defs, AlphaMode, DrawMesh, Material, MaterialPipeline,
+    setup_morph_and_skinning_defs, AlphaMode, DrawMesh, Material, MaterialPipeline,
     MaterialPipelineKey, MeshLayouts, MeshPipeline, MeshPipelineKey, MeshTransforms,
-    RenderMaterials, SetMaterialBindGroup, SetMeshBindGroup,
+    RenderMaterials, SetMaterialBindGroup, SetMeshBindGroup, prepare_materials,
 };
 
 use std::{hash::Hash, marker::PhantomData};
@@ -105,7 +105,7 @@ where
         render_app
             .add_systems(
                 Render,
-                prepare_prepass_view_bind_group::<M>.in_set(RenderSet::Prepare),
+                prepare_prepass_view_bind_group::<M>.in_set(RenderSet::PrepareBindgroups),
             )
             .init_resource::<PrepassViewBindGroup>()
             .init_resource::<SpecializedMeshPipelines<PrepassPipeline<M>>>()
@@ -161,15 +161,7 @@ where
                 .add_systems(ExtractSchedule, extract_camera_previous_view_projection)
                 .add_systems(
                     Render,
-                    (
-                        prepare_previous_view_projection_uniforms
-                            .in_set(RenderSet::Prepare)
-                            .after(PrepassLightsViewFlush),
-                        apply_deferred
-                            .in_set(RenderSet::Prepare)
-                            .in_set(PrepassLightsViewFlush)
-                            .after(prepare_lights),
-                    ),
+                    prepare_previous_view_projection_uniforms.in_set(RenderSet::PrepareBuffers),
                 );
         }
 
@@ -178,7 +170,7 @@ where
             .add_render_command::<AlphaMask3dPrepass, DrawPrepass<M>>()
             .add_systems(
                 Render,
-                queue_prepass_material_meshes::<M>.in_set(RenderSet::Queue),
+                queue_prepass_material_meshes::<M>.in_set(RenderSet::QueueMeshes).after(prepare_materials::<M>)
             );
     }
 }

crates/bevy_pbr/src/render/fog.rs

@@ -113,12 +113,6 @@ pub fn prepare_fog(
         .write_buffer(&render_device, &render_queue);
 }
 
-/// Labels for fog-related systems
-#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
-pub enum RenderFogSystems {
-    PrepareFog,
-}
-
 /// Inserted on each `Entity` with an `ExtractedView` to keep track of its offset
 /// in the `gpu_fogs` `DynamicUniformBuffer` within `FogMeta`
 #[derive(Component)]
@@ -143,11 +137,7 @@ impl Plugin for FogPlugin {
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app
                 .init_resource::<FogMeta>()
-                .add_systems(Render, prepare_fog.in_set(RenderFogSystems::PrepareFog))
-                .configure_set(
-                    Render,
-                    RenderFogSystems::PrepareFog.in_set(RenderSet::Prepare),
-                );
+                .add_systems(Render, prepare_fog.in_set(RenderSet::PrepareBuffers));
         }
     }
 }

crates/bevy_pbr/src/render/light.rs

@@ -32,15 +32,6 @@ use bevy_utils::{
 };
 use std::{hash::Hash, num::NonZeroU64};
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
-pub enum RenderLightSystems {
-    ExtractClusters,
-    ExtractLights,
-    PrepareClusters,
-    PrepareLights,
-    QueueShadows,
-}
-
 #[derive(Component)]
 pub struct ExtractedPointLight {
     color: Color,

crates/bevy_pbr/src/render/mesh.rs

@@ -37,7 +37,7 @@ use bevy_render::{
         BevyDefault, DefaultImageSampler, FallbackImageCubemap, FallbackImagesDepth,
         FallbackImagesMsaa, GpuImage, Image, ImageSampler, TextureFormatPixelInfo,
     },
-    view::{ComputedVisibility, ViewSet, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms},
+    view::{ComputedVisibility, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms},
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_transform::components::GlobalTransform;
@@ -128,15 +128,11 @@ impl Plugin for MeshRenderPlugin {
                 .add_systems(
                     Render,
                     (
-                        prepare_mesh_uniforms.in_set(RenderSet::Prepare),
-                        prepare_skinned_meshes.in_set(RenderSet::Prepare),
-                        prepare_morphs.in_set(RenderSet::Prepare),
-                        prepare_mesh_bind_group
-                            .in_set(RenderSet::Prepare)
-                            .after(ViewSet::PrepareUniforms),
-                        prepare_mesh_view_bind_groups
-                            .in_set(RenderSet::Prepare)
-                            .after(ViewSet::PrepareUniforms),
+                        prepare_mesh_uniforms.in_set(RenderSet::PrepareBuffers),
+                        prepare_skinned_meshes.in_set(RenderSet::PrepareBuffers),
+                        prepare_morphs.in_set(RenderSet::PrepareBuffers),
+                        prepare_mesh_bind_group.in_set(RenderSet::PrepareBindgroups),
+                        prepare_mesh_view_bind_groups.in_set(RenderSet::PrepareBindgroups),
                     ),
                 );
         }

crates/bevy_pbr/src/ssao/mod.rs

@@ -114,9 +114,14 @@ impl Plugin for ScreenSpaceAmbientOcclusionPlugin {
             .init_resource::<SsaoPipelines>()
             .init_resource::<SpecializedComputePipelines<SsaoPipelines>>()
             .add_systems(ExtractSchedule, extract_ssao_settings)
-            .add_systems(Render, prepare_ssao_textures.in_set(RenderSet::ManageViews))
-            .add_systems(Render, prepare_ssao_pipelines.in_set(RenderSet::Prepare))
-            .add_systems(Render, prepare_ssao_bind_groups.in_set(RenderSet::Prepare))
+            .add_systems(
+                Render, 
+                (
+                    prepare_ssao_pipelines.in_set(RenderSet::Prepare),
+                    prepare_ssao_textures.in_set(RenderSet::PrepareBuffers),
+                    prepare_ssao_bind_groups.in_set(RenderSet::PrepareBindgroups)
+                )
+            )
             .add_render_graph_node::<ViewNodeRunner<SsaoNode>>(
                 CORE_3D,
                 draw_3d_graph::node::SCREEN_SPACE_AMBIENT_OCCLUSION,

crates/bevy_pbr/src/wireframe.rs

@@ -49,7 +49,7 @@ impl Plugin for WireframePlugin {
             render_app
                 .add_render_command::<Opaque3d, DrawWireframes>()
                 .init_resource::<SpecializedMeshPipelines<WireframePipeline>>()
-                .add_systems(Render, queue_wireframes.in_set(RenderSet::Queue));
+                .add_systems(Render, queue_wireframes.in_set(RenderSet::QueueMeshes));
         }
     }
 

crates/bevy_render/src/extract_component.rs

@@ -85,7 +85,7 @@ impl<C: Component + ShaderType + WriteInto + Clone> Plugin for UniformComponentP
                 .insert_resource(ComponentUniforms::<C>::default())
                 .add_systems(
                     Render,
-                    prepare_uniform_components::<C>.in_set(RenderSet::Prepare),
+                    prepare_uniform_components::<C>.in_set(RenderSet::PrepareBuffers),
                 );
         }
     }

crates/bevy_render/src/globals.rs

@@ -3,8 +3,7 @@ use crate::{
     prelude::Shader,
     render_resource::{ShaderType, UniformBuffer},
     renderer::{RenderDevice, RenderQueue},
-    view::ViewSet,
-    Extract, ExtractSchedule, Render, RenderApp,
+    Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_app::{App, Plugin};
 use bevy_asset::{load_internal_asset, HandleUntyped};
@@ -30,7 +29,7 @@ impl Plugin for GlobalsPlugin {
                 .add_systems(ExtractSchedule, (extract_frame_count, extract_time))
                 .add_systems(
                     Render,
-                    prepare_globals_buffer.in_set(ViewSet::PrepareUniforms),
+                    prepare_globals_buffer.in_set(RenderSet::PrepareBuffers),
                 );
         }
     }

crates/bevy_render/src/gpu_component_array_buffer.rs

@@ -20,7 +20,7 @@ impl<C: Component + GpuArrayBufferable> Plugin for GpuComponentArrayBufferPlugin
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app.add_systems(
                 Render,
-                prepare_gpu_component_array_buffers::<C>.in_set(RenderSet::Prepare),
+                prepare_gpu_component_array_buffers::<C>.in_set(RenderSet::PrepareBuffers),
             );
         }
     }