Revert "extract node 3d to core pipeline"

This reverts commit ef546ce.

Author: tim-blackbird

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -12,7 +12,6 @@ pub mod graph {
         pub const BLOOM: &str = "bloom";
         pub const TONEMAPPING: &str = "tonemapping";
         pub const FXAA: &str = "fxaa";
-        pub const GIZMO: &str = "gizmo";
         pub const UPSCALING: &str = "upscaling";
         pub const END_MAIN_PASS_POST_PROCESSING: &str = "end_main_pass_post_processing";
     }

crates/bevy_core_pipeline/src/gizmo_3d/mod.rs

@@ -5,7 +5,6 @@ pub mod core_3d;
 pub mod fullscreen_vertex_shader;
 pub mod fxaa;
 pub mod gizmo_2d;
-pub mod gizmo_3d;
 pub mod prepass;
 pub mod tonemapping;
 pub mod upscaling;

crates/bevy_core_pipeline/src/lib.rs

@@ -3,8 +3,8 @@ use std::mem;
 use bevy_app::{CoreSet, IntoSystemAppConfig, Plugin};
 use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
 use bevy_core_pipeline::{
+    core_3d,
     gizmo_2d::{Gizmo2dPlugin, GizmoLine2d},
-    gizmo_3d::{Gizmo3dPlugin, GizmoLine3d},
 };
 use bevy_ecs::{
     prelude::{Component, DetectChanges},
@@ -16,7 +16,8 @@ use bevy_math::Mat4;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     mesh::Mesh,
-    render_phase::AddRenderCommand,
+    render_graph::RenderGraph,
+    render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
     render_resource::{PrimitiveTopology, Shader, SpecializedMeshPipelines},
     Extract, ExtractSchedule, RenderApp, RenderSet,
 };
@@ -28,12 +29,14 @@ use bevy_sprite::{Mesh2dHandle, Mesh2dUniform};
 
 pub mod gizmos;
 
+mod node_3d;
+
 #[cfg(feature = "bevy_sprite")]
 mod pipeline_2d;
 #[cfg(feature = "bevy_pbr")]
 mod pipeline_3d;
 
-use crate::gizmos::GizmoStorage;
+use crate::{gizmos::GizmoStorage, node_3d::GizmoNode3d};
 
 /// The `bevy_gizmos` prelude.
 pub mod prelude {
@@ -58,9 +61,6 @@ impl Plugin for GizmoPlugin {
         #[cfg(feature = "bevy_sprite")]
         app.add_plugin(Gizmo2dPlugin);
 
-        #[cfg(feature = "bevy_pbr")]
-        app.add_plugin(Gizmo3dPlugin);
-
         let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return; };
 
         render_app.add_system(extract_gizmo_data.in_schedule(ExtractSchedule));
@@ -83,8 +83,28 @@ impl Plugin for GizmoPlugin {
             render_app
                 .init_resource::<GizmoPipeline3d>()
                 .init_resource::<SpecializedMeshPipelines<GizmoPipeline3d>>()
+                .init_resource::<DrawFunctions<GizmoLine3d>>()
                 .add_render_command::<GizmoLine3d, DrawGizmoLines>()
+                .add_system(sort_phase_system::<GizmoLine3d>)
+                .add_system_to_schedule(ExtractSchedule, extract_gizmo_line_3d_camera_phase)
                 .add_system(queue_gizmos_3d.in_set(RenderSet::Queue));
+
+            let gizmo_node = GizmoNode3d::new(&mut render_app.world);
+            let mut binding = render_app.world.resource_mut::<RenderGraph>();
+            let graph = binding.get_sub_graph_mut(core_3d::graph::NAME).unwrap();
+
+            graph.add_node(GizmoNode3d::NAME, gizmo_node);
+            graph.add_slot_edge(
+                graph.input_node().id,
+                core_3d::graph::input::VIEW_ENTITY,
+                GizmoNode3d::NAME,
+                GizmoNode3d::IN_VIEW,
+            );
+            graph.add_node_edge(
+                core_3d::graph::node::END_MAIN_PASS_POST_PROCESSING,
+                GizmoNode3d::NAME,
+            );
+            graph.add_node_edge(GizmoNode3d::NAME, core_3d::graph::node::UPSCALING);
         }
     }
 }

crates/bevy_gizmos/src/lib.rs

@@ -1,3 +1,4 @@
+use bevy_core_pipeline::core_3d::Camera3dDepthLoadOp;
 use bevy_ecs::prelude::*;
 use bevy_render::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
@@ -6,14 +7,10 @@ use bevy_render::{
     renderer::RenderContext,
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
-#[cfg(feature = "trace")]
-use bevy_utils::tracing::info_span;
 
-use crate::core_3d::Camera3dDepthLoadOp;
+use crate::pipeline_3d::GizmoLine3d;
 
-use super::GizmoLine3d;
-
-pub struct Gizmo3dNode {
+pub struct GizmoNode3d {
     view_query: QueryState<
         (
             &'static ViewTarget,
@@ -24,8 +21,9 @@ pub struct Gizmo3dNode {
     >,
 }
 
-impl Gizmo3dNode {
+impl GizmoNode3d {
     pub const IN_VIEW: &'static str = "view";
+    pub const NAME: &'static str = "gizmo_node_2d";
 
     pub fn new(world: &mut World) -> Self {
         Self {
@@ -34,7 +32,7 @@ impl Gizmo3dNode {
     }
 }
 
-impl Node for Gizmo3dNode {
+impl Node for GizmoNode3d {
     fn input(&self) -> Vec<SlotInfo> {
         vec![SlotInfo::new(Self::IN_VIEW, SlotType::Entity)]
     }

crates/bevy_core_pipeline/src/gizmo_3d/node.rs renamed to crates/bevy_gizmos/src/node_3d.rs

@@ -1,16 +1,21 @@
+use std::cmp::Reverse;
+
 use bevy_asset::Handle;
-use bevy_core_pipeline::gizmo_3d::GizmoLine3d;
+use bevy_core_pipeline::prelude::Camera3d;
 use bevy_ecs::{
     entity::Entity,
     query::With,
-    system::{Query, Res, ResMut, Resource},
+    system::{Commands, Query, Res, ResMut, Resource},
     world::{FromWorld, World},
 };
 use bevy_pbr::*;
 use bevy_render::{
     mesh::Mesh,
+    prelude::Camera,
+    render_phase::{CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItem},
     render_resource::Shader,
     view::{ExtractedView, ViewTarget},
+    Extract,
 };
 use bevy_render::{
     mesh::MeshVertexBufferLayout,
@@ -20,6 +25,7 @@ use bevy_render::{
     texture::BevyDefault,
     view::Msaa,
 };
+use bevy_utils::FloatOrd;
 
 use crate::{GizmoConfig, GizmoMesh, LINE_SHADER_HANDLE};
 
@@ -125,6 +131,59 @@ pub(crate) type DrawGizmoLines = (
     DrawMesh,
 );
 
+pub struct GizmoLine3d {
+    pub distance: f32,
+    pub pipeline: CachedRenderPipelineId,
+    pub entity: Entity,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for GizmoLine3d {
+    // NOTE: Values increase towards the camera. Front-to-back ordering for opaque means we need a descending sort.
+    type SortKey = Reverse<FloatOrd>;
+
+    #[inline]
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        Reverse(FloatOrd(self.distance))
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+
+    #[inline]
+    fn sort(items: &mut [Self]) {
+        // Key negated to match reversed SortKey ordering
+        radsort::sort_by_key(items, |item| -item.distance);
+    }
+}
+
+impl CachedRenderPipelinePhaseItem for GizmoLine3d {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedRenderPipelineId {
+        self.pipeline
+    }
+}
+
+pub fn extract_gizmo_line_3d_camera_phase(
+    mut commands: Commands,
+    cameras_3d: Extract<Query<(Entity, &Camera), With<Camera3d>>>,
+) {
+    for (entity, camera) in &cameras_3d {
+        if camera.is_active {
+            commands
+                .get_or_spawn(entity)
+                .insert(RenderPhase::<GizmoLine3d>::default());
+        }
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn queue_gizmos_3d(
     draw_functions: Res<DrawFunctions<GizmoLine3d>>,