ugh

Author: tim-blackbird

crates/bevy_debug_draw/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_debug_draw"
-version = "0.9.0-dev"
+version = "0.9.0"
 edition = "2021"
 description = "Provides debug drawing for Bevy Engine"
 homepage = "https://bevyengine.org"
@@ -10,17 +10,17 @@ keywords = ["bevy"]
 
 [dependencies]
 # Bevy
-bevy_pbr = { path = "../bevy_pbr", version = "0.9.0-dev", optional = true }
-bevy_sprite = { path = "../bevy_sprite", version = "0.9.0-dev", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.9.0-dev" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.9.0-dev" }
-bevy_math = { path = "../bevy_math", version = "0.9.0-dev" }
-bevy_asset = { path = "../bevy_asset", version = "0.9.0-dev" }
-bevy_render = { path = "../bevy_render", version = "0.9.0-dev" }
-bevy_utils = { path = "../bevy_utils", version = "0.9.0-dev" }
-bevy_core = { path = "../bevy_core", version = "0.9.0-dev" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.9.0-dev" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.9.0-dev" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.9.0", optional = true }
+bevy_sprite = { path = "../bevy_sprite", version = "0.9.0", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.9.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.9.0" }
+bevy_math = { path = "../bevy_math", version = "0.9.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.9.0" }
+bevy_render = { path = "../bevy_render", version = "0.9.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.9.0" }
+bevy_core = { path = "../bevy_core", version = "0.9.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.9.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.9.0" }
 # Other
 once_cell = "1.16"
 crossbeam-channel = "0.5"

crates/bevy_debug_draw/src/gizmos.rs

@@ -84,26 +84,20 @@ impl Gizmos {
     /// Draw a rectangle.
     #[inline]
     pub fn rect(&self, position: Vec3, rotation: Quat, size: Vec2, color: Color) {
-        let positions = self
+        let [tl, tr, br, bl] = self
             .rect_inner(size)
             .map(|vec2| position + rotation * vec2.extend(0.));
-        self.linestrip(positions, color);
+        self.linestrip([tl, tr, br, bl, tl], color);
     }
 
     /// Draw a box.
     #[inline]
     pub fn cuboid(&self, position: Vec3, rotation: Quat, size: Vec3, color: Color) {
-        let half_size = size / 2.;
+        let rect = self.rect_inner(size.truncate());
         // Front
-        let tlf = position + rotation * Vec3::new(-half_size.x, half_size.y, half_size.z);
-        let trf = position + rotation * Vec3::new(half_size.x, half_size.y, half_size.z);
-        let blf = position + rotation * Vec3::new(-half_size.x, -half_size.y, half_size.z);
-        let brf = position + rotation * Vec3::new(half_size.x, -half_size.y, half_size.z);
+        let [tlf, trf, brf, blf] = rect.map(|vec2| position + rotation * vec2.extend(size.z / 2.));
         // Back
-        let tlb = position + rotation * Vec3::new(-half_size.x, half_size.y, -half_size.z);
-        let trb = position + rotation * Vec3::new(half_size.x, half_size.y, -half_size.z);
-        let blb = position + rotation * Vec3::new(-half_size.x, -half_size.y, -half_size.z);
-        let brb = position + rotation * Vec3::new(half_size.x, -half_size.y, -half_size.z);
+        let [tlb, trb, brb, blb] = rect.map(|vec2| position + rotation * vec2.extend(-size.z / 2.));
 
         let positions = [
             tlf, trf, trf, brf, brf, blf, blf, tlf, // Front
@@ -162,8 +156,8 @@ impl Gizmos {
     #[inline]
     pub fn rect_2d(&self, position: Vec2, rotation: f32, size: Vec2, color: Color) {
         let rotation = Mat2::from_angle(rotation);
-        let positions = self.rect_inner(size).map(|vec2| position + rotation * vec2);
-        self.linestrip_2d(positions, color);
+        let [tl, tr, br, bl] = self.rect_inner(size).map(|vec2| position + rotation * vec2);
+        self.linestrip_2d([tl, tr, br, bl, tl], color);
     }
 
     fn circle_inner(&self, radius: f32) -> impl Iterator<Item = Vec2> {
@@ -174,14 +168,13 @@ impl Gizmos {
         })
     }
 
-    fn rect_inner(&self, size: Vec2) -> impl Iterator<Item = Vec2> {
+    fn rect_inner(&self, size: Vec2) -> [Vec2; 4] {
         let half_size = size / 2.;
         let tl = Vec2::new(-half_size.x, half_size.y);
         let tr = Vec2::new(half_size.x, half_size.y);
         let bl = Vec2::new(-half_size.x, -half_size.y);
         let br = Vec2::new(half_size.x, -half_size.y);
-
-        [tl, tr, br, bl, tl].into_iter()
+        [tl, tr, br, bl]
     }
 
     #[inline]

crates/bevy_debug_draw/src/lib.rs

@@ -13,15 +13,14 @@ use bevy_render::{
     mesh::Mesh,
     render_phase::AddRenderCommand,
     render_resource::{PrimitiveTopology, Shader, SpecializedMeshPipelines},
-    RenderApp, RenderStage, Extract, view::NoFrustumCulling,
+    Extract, RenderApp, RenderStage,
 };
 
 #[cfg(feature = "bevy_pbr")]
 use bevy_pbr::MeshUniform;
 #[cfg(feature = "bevy_sprite")]
-use bevy_sprite::Mesh2dHandle;
+use bevy_sprite::{Mesh2dHandle, Mesh2dUniform};
 
-use bevy_sprite::Mesh2dUniform;
 use once_cell::sync::Lazy;
 
 pub mod gizmos;
@@ -36,7 +35,7 @@ use crate::gizmos::Gizmos;
 /// The `bevy_debug_draw` prelude.
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{DebugDrawPlugin, GizmoConfig, GIZMOS};
+    pub use crate::{GizmoConfig, GIZMOS};
 }
 
 const SHADER_HANDLE: HandleUntyped =
@@ -50,7 +49,7 @@ impl Plugin for DebugDrawPlugin {
 
         app.init_resource::<MeshHandles>()
             .init_resource::<GizmoConfig>()
-            .add_system_to_stage(CoreStage::Last, sys);
+            .add_system_to_stage(CoreStage::Last, system);
 
         let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return; };
 
@@ -93,14 +92,14 @@ pub struct GizmoConfig {
     /// This setting only affects 3D. In 2D, debug drawing is always on top.
     ///
     /// Defaults to `true`.
-    pub always_on_top: bool,
+    pub on_top: bool,
 }
 
 impl Default for GizmoConfig {
     fn default() -> Self {
         Self {
             enabled: true,
-            always_on_top: true,
+            on_top: true,
         }
     }
 }
@@ -116,7 +115,7 @@ enum SendItem {
 
 pub static GIZMOS: Lazy<Gizmos> = Lazy::new(Gizmos::new);
 
-fn sys(mut meshes: ResMut<Assets<Mesh>>, handles: Res<MeshHandles>) {
+fn system(mut meshes: ResMut<Assets<Mesh>>, handles: Res<MeshHandles>) {
     let mut list_positions = Vec::new();
     let mut list_colors = Vec::new();
     let mut strip_positions = Vec::new();
@@ -128,7 +127,6 @@ fn sys(mut meshes: ResMut<Assets<Mesh>>, handles: Res<MeshHandles>) {
                 list_positions.extend(positions);
                 list_colors.extend(colors);
             }
-
             SendItem::List((positions, colors)) => {
                 list_positions.extend(positions);
                 list_colors.extend(colors);
@@ -171,8 +169,11 @@ impl FromWorld for MeshHandles {
 #[derive(Component)]
 struct GizmoDrawMesh;
 
-fn extract(mut commands: Commands, handles: Extract<Res<MeshHandles>>, config: Extract<Res<GizmoConfig>>) {
-
+fn extract(
+    mut commands: Commands,
+    handles: Extract<Res<MeshHandles>>,
+    config: Extract<Res<GizmoConfig>>,
+) {
     if config.is_changed() {
         commands.insert_resource(**config);
     }

crates/bevy_debug_draw/src/pipeline_2d.rs

@@ -97,19 +97,19 @@ pub(crate) fn queue(
     pipeline: Res<DebugLinePipeline>,
     mut pipeline_cache: ResMut<PipelineCache>,
     mut specialized_pipelines: ResMut<SpecializedMeshPipelines<DebugLinePipeline>>,
-    render_meshes: Res<RenderAssets<Mesh>>,
+    gpu_meshes: Res<RenderAssets<Mesh>>,
     msaa: Res<Msaa>,
-    material_meshes: Query<&Mesh2dHandle, With<GizmoDrawMesh>>,
+    mesh_handles: Query<&Mesh2dHandle, With<GizmoDrawMesh>>,
     mut views: Query<(&VisibleEntities, &mut RenderPhase<Transparent2d>)>,
 ) {
-    let draw_mesh2d = draw_functions.read().get_id::<DrawDebugLines>().unwrap();
+    let draw_function = draw_functions.read().get_id::<DrawDebugLines>().unwrap();
     let key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut phase) in &mut views {
         for visible_entity in &view.entities {
             println!("e");
-            let Ok(mesh_handle) = material_meshes.get(*visible_entity) else { continue; };
+            let Ok(mesh_handle) = mesh_handles.get(*visible_entity) else { continue; };
             println!("ee");
-            let Some(mesh) = render_meshes.get(&mesh_handle.0) else { continue; };
+            let Some(mesh) = gpu_meshes.get(&mesh_handle.0) else { continue; };
             println!("eee");
 
             let key = key | Mesh2dPipelineKey::from_primitive_topology(mesh.primitive_topology);
@@ -118,7 +118,7 @@ pub(crate) fn queue(
                 .unwrap();
             phase.add(Transparent2d {
                 entity: *visible_entity,
-                draw_function: draw_mesh2d,
+                draw_function,
                 pipeline,
                 sort_key: FloatOrd(f32::MAX),
                 batch_range: None,

crates/bevy_debug_draw/src/pipeline_3d.rs

@@ -2,8 +2,9 @@ use bevy_asset::Handle;
 use bevy_core_pipeline::core_3d::Opaque3d;
 use bevy_ecs::{
     entity::Entity,
+    query::With,
     system::{Query, Res, ResMut, Resource},
-    world::{FromWorld, World}, query::With,
+    world::{FromWorld, World},
 };
 use bevy_pbr::*;
 use bevy_render::{mesh::Mesh, render_resource::Shader};
@@ -42,9 +43,13 @@ impl SpecializedMeshPipeline for DebugLinePipeline {
         layout: &MeshVertexBufferLayout,
     ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
         let mut shader_defs = Vec::new();
-        shader_defs.push("DEBUG_LINES_3D".to_string());
+        shader_defs.push("DEBUG_LINES_3D".into());
+        shader_defs.push(ShaderDefVal::Int(
+            "MAX_DIRECTIONAL_LIGHTS".to_string(),
+            MAX_DIRECTIONAL_LIGHTS as i32,
+        ));
         if depth_test {
-            shader_defs.push("DEPTH_TEST".to_string());
+            shader_defs.push("DEPTH_TEST".into());
         }
 
         let vertex_buffer_layout = layout.get_layout(&[
@@ -139,10 +144,7 @@ pub(crate) fn queue(
     config: Res<GizmoConfig>,
     mut views: Query<(&ExtractedView, &mut RenderPhase<Opaque3d>)>,
 ) {
-    let draw_custom = draw_functions
-        .read()
-        .get_id::<DrawDebugLines>()
-        .unwrap();
+    let draw_function = draw_functions.read().get_id::<DrawDebugLines>().unwrap();
     let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut phase) in &mut views {
         let view_matrix = view.transform.compute_matrix();
@@ -154,14 +156,14 @@ pub(crate) fn queue(
                     .specialize(
                         &mut pipeline_cache,
                         &pipeline,
-                        (!config.always_on_top, key),
+                        (!config.on_top, key),
                         &mesh.layout,
                     )
                     .unwrap();
                 phase.add(Opaque3d {
                     entity,
                     pipeline,
-                    draw_function: draw_custom,
+                    draw_function,
                     distance: view_row_2.dot(mesh_uniform.transform.col(3)),
                 });
             }

examples/stress_tests/many_debug_lines.rs

@@ -22,7 +22,7 @@ fn main() {
             fancy: false,
         })
         .insert_resource(GizmoConfig {
-            always_on_top: false,
+            on_top: false,
             ..default()
         })
         .add_startup_system(setup)