ogo

Author: tim-blackbird

crates/bevy_debug_draw/src/lib.rs

@@ -58,9 +58,9 @@ impl Plugin for DebugDrawPlugin {
             use pipeline_2d::*;
 
             render_app
-                .add_render_command::<Transparent2d, DrawDebugLines>()
-                .init_resource::<DebugLinePipeline>()
-                .init_resource::<SpecializedMeshPipelines<DebugLinePipeline>>()
+                .add_render_command::<Transparent2d, DrawGizmoLines>()
+                .init_resource::<GizmoLinePipeline>()
+                .init_resource::<SpecializedMeshPipelines<GizmoLinePipeline>>()
                 .add_system_to_stage(RenderStage::Queue, queue);
         }
 
@@ -70,9 +70,9 @@ impl Plugin for DebugDrawPlugin {
             use pipeline_3d::*;
 
             render_app
-                .add_render_command::<Opaque3d, DrawDebugLines>()
-                .init_resource::<DebugLinePipeline>()
-                .init_resource::<SpecializedMeshPipelines<DebugLinePipeline>>()
+                .add_render_command::<Opaque3d, DrawGizmoLines>()
+                .init_resource::<GizmoLinePipeline>()
+                .init_resource::<SpecializedMeshPipelines<GizmoLinePipeline>>()
                 .add_system_to_stage(RenderStage::Queue, queue);
         }
     }

crates/bevy_debug_draw/src/pipeline_2d.rs

@@ -20,21 +20,21 @@ use bevy_utils::FloatOrd;
 use crate::{GizmoDrawMesh, SHADER_HANDLE};
 
 #[derive(Resource)]
-pub(crate) struct DebugLinePipeline {
+pub(crate) struct GizmoLinePipeline {
     mesh_pipeline: Mesh2dPipeline,
     shader: Handle<Shader>,
 }
 
-impl FromWorld for DebugLinePipeline {
+impl FromWorld for GizmoLinePipeline {
     fn from_world(render_world: &mut World) -> Self {
-        DebugLinePipeline {
+        GizmoLinePipeline {
             mesh_pipeline: render_world.resource::<Mesh2dPipeline>().clone(),
             shader: SHADER_HANDLE.typed(),
         }
     }
 }
 
-impl SpecializedMeshPipeline for DebugLinePipeline {
+impl SpecializedMeshPipeline for GizmoLinePipeline {
     type Key = Mesh2dPipelineKey;
 
     fn specialize(
@@ -85,7 +85,7 @@ impl SpecializedMeshPipeline for DebugLinePipeline {
     }
 }
 
-pub(crate) type DrawDebugLines = (
+pub(crate) type DrawGizmoLines = (
     SetItemPipeline,
     SetMesh2dViewBindGroup<0>,
     SetMesh2dBindGroup<1>,
@@ -95,15 +95,15 @@ pub(crate) type DrawDebugLines = (
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn queue(
     draw_functions: Res<DrawFunctions<Transparent2d>>,
-    pipeline: Res<DebugLinePipeline>,
+    pipeline: Res<GizmoLinePipeline>,
     mut pipeline_cache: ResMut<PipelineCache>,
-    mut specialized_pipelines: ResMut<SpecializedMeshPipelines<DebugLinePipeline>>,
+    mut specialized_pipelines: ResMut<SpecializedMeshPipelines<GizmoLinePipeline>>,
     gpu_meshes: Res<RenderAssets<Mesh>>,
     msaa: Res<Msaa>,
     mesh_handles: Query<(Entity, &Mesh2dHandle), With<GizmoDrawMesh>>,
     mut views: Query<&mut RenderPhase<Transparent2d>>,
 ) {
-    let draw_function = draw_functions.read().get_id::<DrawDebugLines>().unwrap();
+    let draw_function = draw_functions.read().get_id::<DrawGizmoLines>().unwrap();
     let key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples);
     for mut phase in &mut views {
         for (entity, mesh_handle) in &mesh_handles {

crates/bevy_debug_draw/src/pipeline_3d.rs

@@ -14,27 +14,27 @@ use bevy_render::{
     render_phase::{DrawFunctions, RenderPhase, SetItemPipeline},
     render_resource::*,
     texture::BevyDefault,
-    view::{ExtractedView, Msaa},
+    view::Msaa,
 };
 
 use crate::{GizmoConfig, GizmoDrawMesh, SHADER_HANDLE};
 
 #[derive(Resource)]
-pub(crate) struct DebugLinePipeline {
+pub(crate) struct GizmoLinePipeline {
     mesh_pipeline: MeshPipeline,
     shader: Handle<Shader>,
 }
 
-impl FromWorld for DebugLinePipeline {
+impl FromWorld for GizmoLinePipeline {
     fn from_world(render_world: &mut World) -> Self {
-        DebugLinePipeline {
+        GizmoLinePipeline {
             mesh_pipeline: render_world.resource::<MeshPipeline>().clone(),
             shader: SHADER_HANDLE.typed(),
         }
     }
 }
 
-impl SpecializedMeshPipeline for DebugLinePipeline {
+impl SpecializedMeshPipeline for GizmoLinePipeline {
     type Key = (bool, MeshPipelineKey);
 
     fn specialize(
@@ -125,7 +125,7 @@ impl SpecializedMeshPipeline for DebugLinePipeline {
     }
 }
 
-pub(crate) type DrawDebugLines = (
+pub(crate) type DrawGizmoLines = (
     SetItemPipeline,
     SetMeshViewBindGroup<0>,
     SetMeshBindGroup<1>,
@@ -135,20 +135,19 @@ pub(crate) type DrawDebugLines = (
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn queue(
     draw_functions: Res<DrawFunctions<Opaque3d>>,
-    pipeline: Res<DebugLinePipeline>,
-    mut pipelines: ResMut<SpecializedMeshPipelines<DebugLinePipeline>>,
+    pipeline: Res<GizmoLinePipeline>,
+    mut pipelines: ResMut<SpecializedMeshPipelines<GizmoLinePipeline>>,
     mut pipeline_cache: ResMut<PipelineCache>,
     render_meshes: Res<RenderAssets<Mesh>>,
     msaa: Res<Msaa>,
-    material_meshes: Query<(Entity, &Handle<Mesh>), With<GizmoDrawMesh>>,
+    mesh_handles: Query<(Entity, &Handle<Mesh>), With<GizmoDrawMesh>>,
     config: Res<GizmoConfig>,
-    mut views: Query<(&ExtractedView, &mut RenderPhase<Opaque3d>)>,
+    mut views: Query<&mut RenderPhase<Opaque3d>>,
 ) {
-    let draw_function = draw_functions.read().get_id::<DrawDebugLines>().unwrap();
+    let draw_function = draw_functions.read().get_id::<DrawGizmoLines>().unwrap();
     let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
-    for (view, mut phase) in &mut views {
-        let view_matrix = view.transform.compute_matrix();
-        for (entity, mesh_handle) in &material_meshes {
+    for mut phase in &mut views {
+        for (entity, mesh_handle) in &mesh_handles {
             if let Some(mesh) = render_meshes.get(mesh_handle) {
                 let key = key | MeshPipelineKey::from_primitive_topology(mesh.primitive_topology);
                 let pipeline = pipelines