Rename Core Render Graph Labels (#11882)

# Objective

#10644 introduced nice "statically typed" labels that replace the old
strings. I would like to propose some changes to the names introduced:

* `SubGraph2d` -> `Core2d` and `SubGraph3d` -> `Core3d`. The names of
these graphs have been / should continue to be the "core 2d" graph not
the "sub graph 2d" graph. The crate is called `bevy_core_pipeline`, the
modules are still `core_2d` and `core_3d`, etc.
* `Labels2d` and `Labels3d`, at the very least, should not be plural to
follow naming conventions. A Label enum is not a "collection of labels",
it is a _specific_ Label. However I think `Label2d` and `Label3d` is
significantly less clear than `Node2d` and `Node3d`, so I propose those
changes here. I've done the same for `LabelsPbr` -> `NodePbr` and
`LabelsUi` -> `NodeUi`

Additionally, #10644 accidentally made one of the Camera2dBundle
constructors use the 3D graph instead of the 2D graph. I've fixed that
here.
 
---

## Changelog

* Renamed `SubGraph2d` -> `Core2d`, `SubGraph3d` -> `Core3d`, `Labels2d`
-> `Node2d`, `Labels3d` -> `Node3d`, `LabelsUi` -> `NodeUi`, `LabelsPbr`
-> `NodePbr`

Author: cart

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -5,8 +5,8 @@ mod upsampling_pipeline;
 pub use settings::{BloomCompositeMode, BloomPrefilterSettings, BloomSettings};
 
 use crate::{
-    core_2d::graph::{Labels2d, SubGraph2d},
-    core_3d::graph::{Labels3d, SubGraph3d},
+    core_2d::graph::{Core2d, Node2d},
+    core_3d::graph::{Core3d, Node3d},
 };
 use bevy_app::{App, Plugin};
 use bevy_asset::{load_internal_asset, Handle};
@@ -72,20 +72,16 @@ impl Plugin for BloomPlugin {
                 ),
             )
             // Add bloom to the 3d render graph
-            .add_render_graph_node::<ViewNodeRunner<BloomNode>>(SubGraph3d, Labels3d::Bloom)
+            .add_render_graph_node::<ViewNodeRunner<BloomNode>>(Core3d, Node3d::Bloom)
             .add_render_graph_edges(
-                SubGraph3d,
-                (
-                    Labels3d::EndMainPass,
-                    Labels3d::Bloom,
-                    Labels3d::Tonemapping,
-                ),
+                Core3d,
+                (Node3d::EndMainPass, Node3d::Bloom, Node3d::Tonemapping),
             )
             // Add bloom to the 2d render graph
-            .add_render_graph_node::<ViewNodeRunner<BloomNode>>(SubGraph2d, Labels2d::Bloom)
+            .add_render_graph_node::<ViewNodeRunner<BloomNode>>(Core2d, Node2d::Bloom)
             .add_render_graph_edges(
-                SubGraph2d,
-                (Labels2d::MainPass, Labels2d::Bloom, Labels2d::Tonemapping),
+                Core2d,
+                (Node2d::MainPass, Node2d::Bloom, Node2d::Tonemapping),
             );
     }
 

crates/bevy_core_pipeline/src/contrast_adaptive_sharpening/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
-    core_2d::graph::{Labels2d, SubGraph2d},
-    core_3d::graph::{Labels3d, SubGraph3d},
+    core_2d::graph::{Core2d, Node2d},
+    core_3d::graph::{Core3d, Node3d},
     fullscreen_vertex_shader::fullscreen_shader_vertex_state,
 };
 use bevy_app::prelude::*;
@@ -125,35 +125,35 @@ impl Plugin for CASPlugin {
 
         {
             render_app
-                .add_render_graph_node::<CASNode>(SubGraph3d, Labels3d::ContrastAdaptiveSharpening)
+                .add_render_graph_node::<CASNode>(Core3d, Node3d::ContrastAdaptiveSharpening)
                 .add_render_graph_edge(
-                    SubGraph3d,
-                    Labels3d::Tonemapping,
-                    Labels3d::ContrastAdaptiveSharpening,
+                    Core3d,
+                    Node3d::Tonemapping,
+                    Node3d::ContrastAdaptiveSharpening,
                 )
                 .add_render_graph_edges(
-                    SubGraph3d,
+                    Core3d,
                     (
-                        Labels3d::Fxaa,
-                        Labels3d::ContrastAdaptiveSharpening,
-                        Labels3d::EndMainPassPostProcessing,
+                        Node3d::Fxaa,
+                        Node3d::ContrastAdaptiveSharpening,
+                        Node3d::EndMainPassPostProcessing,
                     ),
                 );
         }
         {
             render_app
-                .add_render_graph_node::<CASNode>(SubGraph2d, Labels2d::ConstrastAdaptiveSharpening)
+                .add_render_graph_node::<CASNode>(Core2d, Node2d::ConstrastAdaptiveSharpening)
                 .add_render_graph_edge(
-                    SubGraph2d,
-                    Labels2d::Tonemapping,
-                    Labels2d::ConstrastAdaptiveSharpening,
+                    Core2d,
+                    Node2d::Tonemapping,
+                    Node2d::ConstrastAdaptiveSharpening,
                 )
                 .add_render_graph_edges(
-                    SubGraph2d,
+                    Core2d,
                     (
-                        Labels2d::Fxaa,
-                        Labels2d::ConstrastAdaptiveSharpening,
-                        Labels2d::EndMainPassPostProcessing,
+                        Node2d::Fxaa,
+                        Node2d::ConstrastAdaptiveSharpening,
+                        Node2d::EndMainPassPostProcessing,
                     ),
                 );
         }

crates/bevy_core_pipeline/src/core_2d/camera_2d.rs

@@ -1,7 +1,5 @@
-use crate::{
-    core_3d::graph::SubGraph3d,
-    tonemapping::{DebandDither, Tonemapping},
-};
+use crate::core_2d::graph::Core2d;
+use crate::tonemapping::{DebandDither, Tonemapping};
 use bevy_ecs::prelude::*;
 use bevy_reflect::Reflect;
 use bevy_render::{
@@ -15,8 +13,6 @@ use bevy_render::{
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
-use super::graph::SubGraph2d;
-
 #[derive(Component, Default, Reflect, Clone, ExtractComponent)]
 #[extract_component_filter(With<Camera>)]
 #[reflect(Component)]
@@ -47,7 +43,7 @@ impl Default for Camera2dBundle {
         let transform = Transform::default();
         let frustum = projection.compute_frustum(&GlobalTransform::from(transform));
         Self {
-            camera_render_graph: CameraRenderGraph::new(SubGraph2d),
+            camera_render_graph: CameraRenderGraph::new(Core2d),
             projection,
             visible_entities: VisibleEntities::default(),
             frustum,
@@ -79,7 +75,7 @@ impl Camera2dBundle {
         let transform = Transform::from_xyz(0.0, 0.0, far - 0.1);
         let frustum = projection.compute_frustum(&GlobalTransform::from(transform));
         Self {
-            camera_render_graph: CameraRenderGraph::new(SubGraph3d),
+            camera_render_graph: CameraRenderGraph::new(Core2d),
             projection,
             visible_entities: VisibleEntities::default(),
             frustum,

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -5,14 +5,14 @@ pub mod graph {
     use bevy_render::render_graph::{RenderLabel, RenderSubGraph};
 
     #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderSubGraph)]
-    pub struct SubGraph2d;
+    pub struct Core2d;
 
     pub mod input {
         pub const VIEW_ENTITY: &str = "view_entity";
     }
 
     #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
-    pub enum Labels2d {
+    pub enum Node2d {
         MsaaWriteback,
         MainPass,
         Bloom,
@@ -46,7 +46,7 @@ use bevy_utils::{nonmax::NonMaxU32, FloatOrd};
 
 use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
 
-use self::graph::{Labels2d, SubGraph2d};
+use self::graph::{Core2d, Node2d};
 
 pub struct Core2dPlugin;
 
@@ -68,21 +68,18 @@ impl Plugin for Core2dPlugin {
             );
 
         render_app
-            .add_render_sub_graph(SubGraph2d)
-            .add_render_graph_node::<MainPass2dNode>(SubGraph2d, Labels2d::MainPass)
-            .add_render_graph_node::<ViewNodeRunner<TonemappingNode>>(
-                SubGraph2d,
-                Labels2d::Tonemapping,
-            )
-            .add_render_graph_node::<EmptyNode>(SubGraph2d, Labels2d::EndMainPassPostProcessing)
-            .add_render_graph_node::<ViewNodeRunner<UpscalingNode>>(SubGraph2d, Labels2d::Upscaling)
+            .add_render_sub_graph(Core2d)
+            .add_render_graph_node::<MainPass2dNode>(Core2d, Node2d::MainPass)
+            .add_render_graph_node::<ViewNodeRunner<TonemappingNode>>(Core2d, Node2d::Tonemapping)
+            .add_render_graph_node::<EmptyNode>(Core2d, Node2d::EndMainPassPostProcessing)
+            .add_render_graph_node::<ViewNodeRunner<UpscalingNode>>(Core2d, Node2d::Upscaling)
             .add_render_graph_edges(
-                SubGraph2d,
+                Core2d,
                 (
-                    Labels2d::MainPass,
-                    Labels2d::Tonemapping,
-                    Labels2d::EndMainPassPostProcessing,
-                    Labels2d::Upscaling,
+                    Node2d::MainPass,
+                    Node2d::Tonemapping,
+                    Node2d::EndMainPassPostProcessing,
+                    Node2d::Upscaling,
                 ),
             );
     }

crates/bevy_core_pipeline/src/core_3d/camera_3d.rs

@@ -1,4 +1,7 @@
-use crate::tonemapping::{DebandDither, Tonemapping};
+use crate::{
+    core_3d::graph::Core3d,
+    tonemapping::{DebandDither, Tonemapping},
+};
 use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_render::{
@@ -11,8 +14,6 @@ use bevy_render::{
 use bevy_transform::prelude::{GlobalTransform, Transform};
 use serde::{Deserialize, Serialize};
 
-use super::graph::SubGraph3d;
-
 /// Configuration for the "main 3d render graph".
 #[derive(Component, Reflect, Clone, ExtractComponent)]
 #[extract_component_filter(With<Camera>)]
@@ -153,7 +154,7 @@ pub struct Camera3dBundle {
 impl Default for Camera3dBundle {
     fn default() -> Self {
         Self {
-            camera_render_graph: CameraRenderGraph::new(SubGraph3d),
+            camera_render_graph: CameraRenderGraph::new(Core3d),
             camera: Default::default(),
             projection: Default::default(),
             visible_entities: Default::default(),

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -7,14 +7,14 @@ pub mod graph {
     use bevy_render::render_graph::{RenderLabel, RenderSubGraph};
 
     #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderSubGraph)]
-    pub struct SubGraph3d;
+    pub struct Core3d;
 
     pub mod input {
         pub const VIEW_ENTITY: &str = "view_entity";
     }
 
     #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
-    pub enum Labels3d {
+    pub enum Node3d {
         MsaaWriteback,
         Prepass,
         DeferredPrepass,
@@ -86,7 +86,7 @@ use crate::{
     upscaling::UpscalingNode,
 };
 
-use self::graph::{Labels3d, SubGraph3d};
+use self::graph::{Core3d, Node3d};
 
 pub struct Core3dPlugin;
 
@@ -132,52 +132,49 @@ impl Plugin for Core3dPlugin {
             );
 
         render_app
-            .add_render_sub_graph(SubGraph3d)
-            .add_render_graph_node::<ViewNodeRunner<PrepassNode>>(SubGraph3d, Labels3d::Prepass)
+            .add_render_sub_graph(Core3d)
+            .add_render_graph_node::<ViewNodeRunner<PrepassNode>>(Core3d, Node3d::Prepass)
             .add_render_graph_node::<ViewNodeRunner<DeferredGBufferPrepassNode>>(
-                SubGraph3d,
-                Labels3d::DeferredPrepass,
+                Core3d,
+                Node3d::DeferredPrepass,
             )
             .add_render_graph_node::<ViewNodeRunner<CopyDeferredLightingIdNode>>(
-                SubGraph3d,
-                Labels3d::CopyDeferredLightingId,
+                Core3d,
+                Node3d::CopyDeferredLightingId,
             )
-            .add_render_graph_node::<EmptyNode>(SubGraph3d, Labels3d::EndPrepasses)
-            .add_render_graph_node::<EmptyNode>(SubGraph3d, Labels3d::StartMainPass)
+            .add_render_graph_node::<EmptyNode>(Core3d, Node3d::EndPrepasses)
+            .add_render_graph_node::<EmptyNode>(Core3d, Node3d::StartMainPass)
             .add_render_graph_node::<ViewNodeRunner<MainOpaquePass3dNode>>(
-                SubGraph3d,
-                Labels3d::MainOpaquePass,
+                Core3d,
+                Node3d::MainOpaquePass,
             )
             .add_render_graph_node::<ViewNodeRunner<MainTransmissivePass3dNode>>(
-                SubGraph3d,
-                Labels3d::MainTransmissivePass,
+                Core3d,
+                Node3d::MainTransmissivePass,
             )
             .add_render_graph_node::<ViewNodeRunner<MainTransparentPass3dNode>>(
-                SubGraph3d,
-                Labels3d::MainTransparentPass,
+                Core3d,
+                Node3d::MainTransparentPass,
             )
-            .add_render_graph_node::<EmptyNode>(SubGraph3d, Labels3d::EndMainPass)
-            .add_render_graph_node::<ViewNodeRunner<TonemappingNode>>(
-                SubGraph3d,
-                Labels3d::Tonemapping,
-            )
-            .add_render_graph_node::<EmptyNode>(SubGraph3d, Labels3d::EndMainPassPostProcessing)
-            .add_render_graph_node::<ViewNodeRunner<UpscalingNode>>(SubGraph3d, Labels3d::Upscaling)
+            .add_render_graph_node::<EmptyNode>(Core3d, Node3d::EndMainPass)
+            .add_render_graph_node::<ViewNodeRunner<TonemappingNode>>(Core3d, Node3d::Tonemapping)
+            .add_render_graph_node::<EmptyNode>(Core3d, Node3d::EndMainPassPostProcessing)
+            .add_render_graph_node::<ViewNodeRunner<UpscalingNode>>(Core3d, Node3d::Upscaling)
             .add_render_graph_edges(
-                SubGraph3d,
+                Core3d,
                 (
-                    Labels3d::Prepass,
-                    Labels3d::DeferredPrepass,
-                    Labels3d::CopyDeferredLightingId,
-                    Labels3d::EndPrepasses,
-                    Labels3d::StartMainPass,
-                    Labels3d::MainOpaquePass,
-                    Labels3d::MainTransmissivePass,
-                    Labels3d::MainTransparentPass,
-                    Labels3d::EndMainPass,
-                    Labels3d::Tonemapping,
-                    Labels3d::EndMainPassPostProcessing,
-                    Labels3d::Upscaling,
+                    Node3d::Prepass,
+                    Node3d::DeferredPrepass,
+                    Node3d::CopyDeferredLightingId,
+                    Node3d::EndPrepasses,
+                    Node3d::StartMainPass,
+                    Node3d::MainOpaquePass,
+                    Node3d::MainTransmissivePass,
+                    Node3d::MainTransparentPass,
+                    Node3d::EndMainPass,
+                    Node3d::Tonemapping,
+                    Node3d::EndMainPassPostProcessing,
+                    Node3d::Upscaling,
                 ),
             );
     }

crates/bevy_core_pipeline/src/fxaa/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
-    core_2d::graph::{Labels2d, SubGraph2d},
-    core_3d::graph::{Labels3d, SubGraph3d},
+    core_2d::graph::{Core2d, Node2d},
+    core_3d::graph::{Core3d, Node3d},
     fullscreen_vertex_shader::fullscreen_shader_vertex_state,
 };
 use bevy_app::prelude::*;
@@ -95,22 +95,22 @@ impl Plugin for FxaaPlugin {
         render_app
             .init_resource::<SpecializedRenderPipelines<FxaaPipeline>>()
             .add_systems(Render, prepare_fxaa_pipelines.in_set(RenderSet::Prepare))
-            .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(SubGraph3d, Labels3d::Fxaa)
+            .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(Core3d, Node3d::Fxaa)
             .add_render_graph_edges(
-                SubGraph3d,
+                Core3d,
                 (
-                    Labels3d::Tonemapping,
-                    Labels3d::Fxaa,
-                    Labels3d::EndMainPassPostProcessing,
+                    Node3d::Tonemapping,
+                    Node3d::Fxaa,
+                    Node3d::EndMainPassPostProcessing,
                 ),
             )
-            .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(SubGraph2d, Labels2d::Fxaa)
+            .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(Core2d, Node2d::Fxaa)
             .add_render_graph_edges(
-                SubGraph2d,
+                Core2d,
                 (
-                    Labels2d::Tonemapping,
-                    Labels2d::Fxaa,
-                    Labels2d::EndMainPassPostProcessing,
+                    Node2d::Tonemapping,
+                    Node2d::Fxaa,
+                    Node2d::EndMainPassPostProcessing,
                 ),
             );
     }