Update API. Add basic shapes.

Author: tim-blackbird

Cargo.toml

@@ -204,6 +204,16 @@ description = "Renders a rectangle, circle, and hexagon"
 category = "2D Rendering"
 wasm = true
 
+[[example]]
+name = "2d_debug_draw"
+path = "examples/2d/2d_debug_draw.rs"
+
+[package.metadata.example.2d_debug_draw]
+name = "2D Debug Drawing"
+description = "Simple 2D scene with basic shapes and lighting"
+category = "2D Rendering"
+wasm = true
+
 [[example]]
 name = "sprite"
 path = "examples/2d/sprite.rs"
@@ -285,6 +295,16 @@ description = "A scene showcasing the built-in 3D shapes"
 category = "3D Rendering"
 wasm = true
 
+[[example]]
+name = "3d_debug_draw"
+path = "examples/3d/3d_debug_draw.rs"
+
+[package.metadata.example.3d_debug_draw]
+name = "3D Debug Drawing"
+description = "Simple 3D scene with basic shapes and lighting"
+category = "3D Rendering"
+wasm = true
+
 [[example]]
 name = "lighting"
 path = "examples/3d/lighting.rs"

crates/bevy_debug_draw/Cargo.toml

@@ -8,12 +8,6 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
-[features]
-default = ["2d", "3d"]
-
-3d = ["bevy_pbr"]
-2d = ["bevy_sprite"]
-
 [dependencies]
 bevy_pbr = { path = "../bevy_pbr", version = "0.9.0-dev", optional = true }
 bevy_sprite = { path = "../bevy_sprite", version = "0.9.0-dev", optional = true }

crates/bevy_debug_draw/src/lib.rs

@@ -1,13 +1,13 @@
-use std::{marker::PhantomData, mem};
+use std::f32::consts::TAU;
 
 use bevy_app::{CoreStage, Plugin};
 use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
 use bevy_ecs::{
     prelude::{Component, Entity},
     query::With,
-    system::{Commands, Query, Res, ResMut, Resource, SystemParam},
+    system::{Commands, Query, Res, ResMut, Resource},
 };
-use bevy_math::{Vec2, Vec3};
+use bevy_math::{vec3, Quat, Vec2, Vec3};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     prelude::{Color, Mesh, SpatialBundle},
@@ -16,20 +16,20 @@ use bevy_render::{
     Extract, RenderApp, RenderStage,
 };
 
-#[cfg(feature = "3d")]
+#[cfg(feature = "bevy_pbr")]
 use bevy_pbr::{NotShadowCaster, NotShadowReceiver};
-#[cfg(feature = "2d")]
+#[cfg(feature = "bevy_sprite")]
 use bevy_sprite::Mesh2dHandle;
 
-#[cfg(feature = "2d")]
+#[cfg(feature = "bevy_sprite")]
 pub mod pipeline_2d;
-#[cfg(feature = "3d")]
+#[cfg(feature = "bevy_pbr")]
 pub mod pipeline_3d;
 
 /// The `bevy_debug_draw` prelude.
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{DebugDraw, DebugDraw2d, DebugDrawConfig, DebugDrawPlugin};
+    pub use crate::{DebugDraw, DebugDrawConfig, DebugDrawPlugin};
 }
 
 pub const SHADER_HANDLE: HandleUntyped =
@@ -39,13 +39,15 @@ pub struct DebugDrawPlugin;
 
 impl Plugin for DebugDrawPlugin {
     fn build(&self, app: &mut bevy_app::App) {
-        app.init_resource::<DebugDrawResource>()
+        load_internal_asset!(app, SHADER_HANDLE, "debuglines.wgsl", Shader::from_wgsl);
+
+        app.init_resource::<DebugDraw>()
             .init_resource::<DebugDrawConfig>()
             .add_system_to_stage(CoreStage::PostUpdate, update)
             .sub_app_mut(RenderApp)
             .add_system_to_stage(RenderStage::Extract, extract);
 
-        #[cfg(feature = "2d")]
+        #[cfg(feature = "bevy_sprite")]
         {
             use bevy_core_pipeline::core_2d::Transparent2d;
             use pipeline_2d::*;
@@ -57,7 +59,7 @@ impl Plugin for DebugDrawPlugin {
                 .add_system_to_stage(RenderStage::Queue, queue);
         }
 
-        #[cfg(feature = "3d")]
+        #[cfg(feature = "bevy_pbr")]
         {
             use bevy_core_pipeline::core_3d::Opaque3d;
             use pipeline_3d::*;
@@ -68,13 +70,15 @@ impl Plugin for DebugDrawPlugin {
                 .init_resource::<SpecializedMeshPipelines<DebugLinePipeline>>()
                 .add_system_to_stage(RenderStage::Queue, queue);
         }
-
-        load_internal_asset!(app, SHADER_HANDLE, "debuglines.wgsl", Shader::from_wgsl);
     }
 }
 
 #[derive(Resource, Clone, Copy)]
 pub struct DebugDrawConfig {
+    /// Whether debug drawing should be shown.
+    ///
+    /// Defaults to `true`.
+    pub enabled: bool,
     /// Whether debug drawing should ignore depth and draw on top of everything else.
     ///
     /// Defaults to `true`.
@@ -84,118 +88,188 @@ pub struct DebugDrawConfig {
 impl Default for DebugDrawConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             always_on_top: true,
         }
     }
 }
 
-#[derive(Resource, Default)]
-pub struct DebugDrawResource {
+#[derive(Resource)]
+pub struct DebugDraw {
     positions: Vec<[f32; 3]>,
     colors: Vec<[f32; 4]>,
     mesh_handle: Option<Handle<Mesh>>,
+    /// The amount of line segments to use when drawing a circle.
+    ///
+    /// Defaults to `24`.
+    pub circle_segments: u32,
+}
+
+impl Default for DebugDraw {
+    fn default() -> Self {
+        DebugDraw {
+            positions: Vec::new(),
+            colors: Vec::new(),
+            mesh_handle: None,
+            circle_segments: 24,
+        }
+    }
 }
 
-impl DebugDrawResource {
+impl DebugDraw {
     /// Draw a line from `start` to `end`.
-    fn line(&mut self, start: Vec3, end: Vec3, color: Color) {
-        self.positions
-            .extend_from_slice(&[start.to_array(), end.to_array()]);
+    pub fn line(&mut self, start: Vec3, end: Vec3, color: Color) {
+        self.positions.extend([start.to_array(), end.to_array()]);
         let color = color.as_linear_rgba_f32();
-        self.colors.extend_from_slice(&[color, color]);
+        self.colors.extend([color, color]);
     }
 
     /// Draw a line from `start` to `start + vector`.
-    fn ray(&mut self, start: Vec3, vector: Vec3, color: Color) {
+    pub fn ray(&mut self, start: Vec3, vector: Vec3, color: Color) {
         self.line(start, start + vector, color);
     }
 
-    fn clear(&mut self) {
-        self.positions.clear();
-        self.colors.clear();
-    }
+    /// Draw a circle at `position` with the flat side facing `normal`.
+    pub fn circle(&mut self, position: Vec3, normal: Vec3, radius: f32, color: Color) {
+        let rotation = Quat::from_rotation_arc(Vec3::Z, normal);
+        self.positions
+            .extend((0..self.circle_segments).into_iter().flat_map(|i| {
+                let angle = i as f32 * TAU / self.circle_segments as f32;
 
-    fn update_mesh(&mut self, mesh: &mut Mesh) {
-        mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, mem::take(&mut self.positions));
-        mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, mem::take(&mut self.colors));
-    }
-}
+                let (y, x) = angle.sin_cos();
+                let start = rotation * Vec3::new(x, y, 0.) * radius + position;
 
-#[derive(SystemParam)]
-pub struct DebugDraw<'w, 's> {
-    debug_draw: ResMut<'w, DebugDrawResource>,
-    #[system_param(ignore)]
-    marker: PhantomData<&'s ()>,
-}
+                let (y, x) = (angle + TAU / self.circle_segments as f32).sin_cos();
+                let end = rotation * Vec3::new(x, y, 0.) * radius + position;
 
-impl<'w, 's> DebugDraw<'w, 's> {
-    /// Draw a line from `start` to `end`.
-    pub fn line(&mut self, start: Vec3, end: Vec3, color: Color) {
-        self.debug_draw.line(start, end, color);
+                [start.to_array(), end.to_array()]
+            }));
+
+        self.colors.extend(
+            std::iter::repeat(color.as_linear_rgba_f32()).take(self.circle_segments as usize * 2),
+        );
     }
 
-    /// Draw a line from `start` to `start + vector`.
-    pub fn ray(&mut self, start: Vec3, vector: Vec3, color: Color) {
-        self.debug_draw.ray(start, vector, color);
+    /// Draw a sphere.
+    pub fn sphere(&mut self, position: Vec3, radius: f32, color: Color) {
+        self.circle(position, Vec3::X, radius, color);
+        self.circle(position, Vec3::Y, radius, color);
+        self.circle(position, Vec3::Z, radius, color);
     }
 
-    pub fn clear(&mut self) {
-        self.debug_draw.clear();
+    /// Draw a rectangle.
+    pub fn rect(&mut self, position: Vec3, rotation: Quat, size: Vec2, color: Color) {
+        let half_size = size / 2.;
+        let tl = (position + rotation * vec3(-half_size.x, half_size.y, 0.)).to_array();
+        let tr = (position + rotation * vec3(half_size.x, half_size.y, 0.)).to_array();
+        let bl = (position + rotation * vec3(-half_size.x, -half_size.y, 0.)).to_array();
+        let br = (position + rotation * vec3(half_size.x, -half_size.y, 0.)).to_array();
+        self.positions.extend([tl, tr, tr, br, br, bl, bl, tl]);
+        self.colors
+            .extend(std::iter::repeat(color.as_linear_rgba_f32()).take(8))
     }
-}
 
-#[derive(SystemParam)]
-pub struct DebugDraw2d<'w, 's> {
-    debug_draw: ResMut<'w, DebugDrawResource>,
-    #[system_param(ignore)]
-    marker: PhantomData<&'s ()>,
-}
+    /// Draw a box.
+    pub fn cuboid(&mut self, position: Vec3, rotation: Quat, size: Vec3, color: Color) {
+        let half_size = size / 2.;
+        // Front
+        let tlf = (position + rotation * vec3(-half_size.x, half_size.y, half_size.z)).to_array();
+        let trf = (position + rotation * vec3(half_size.x, half_size.y, half_size.z)).to_array();
+        let blf = (position + rotation * vec3(-half_size.x, -half_size.y, half_size.z)).to_array();
+        let brf = (position + rotation * vec3(half_size.x, -half_size.y, half_size.z)).to_array();
+        // Back
+        let tlb = (position + rotation * vec3(-half_size.x, half_size.y, -half_size.z)).to_array();
+        let trb = (position + rotation * vec3(half_size.x, half_size.y, -half_size.z)).to_array();
+        let blb = (position + rotation * vec3(-half_size.x, -half_size.y, -half_size.z)).to_array();
+        let brb = (position + rotation * vec3(half_size.x, -half_size.y, -half_size.z)).to_array();
+        self.positions.extend([
+            tlf, trf, trf, brf, brf, blf, blf, tlf, // Front
+            tlb, trb, trb, brb, brb, blb, blb, tlb, // Back
+            tlf, tlb, trf, trb, brf, brb, blf, blb, // Front to back
+        ]);
+        self.colors
+            .extend(std::iter::repeat(color.as_linear_rgba_f32()).take(24))
+    }
+
+    /// Draw an axis-aligned box.
+    pub fn aab(&mut self, position: Vec3, size: Vec3, color: Color) {
+        self.cuboid(position, Quat::IDENTITY, size, color);
+    }
 
-impl<'w, 's> DebugDraw2d<'w, 's> {
     /// Draw a line from `start` to `end`.
-    pub fn line(&mut self, start: Vec2, end: Vec2, color: Color) {
-        self.debug_draw
-            .line(start.extend(0.), end.extend(0.), color);
+    pub fn line_2d(&mut self, start: Vec2, end: Vec2, color: Color) {
+        self.line(start.extend(0.), end.extend(0.), color);
     }
 
     /// Draw a line from `start` to `start + vector`.
-    pub fn ray(&mut self, start: Vec2, vector: Vec2, color: Color) {
-        self.debug_draw
-            .ray(start.extend(0.), vector.extend(0.), color);
+    pub fn ray_2d(&mut self, start: Vec2, vector: Vec2, color: Color) {
+        self.ray(start.extend(0.), vector.extend(0.), color);
+    }
+
+    pub fn circle_2d(&mut self, position: Vec2, radius: f32, color: Color) {
+        self.circle(position.extend(0.), Vec3::Z, radius, color);
+    }
+
+    /// Draw a rectangle at `position`.
+    pub fn rect_2d(&mut self, position: Vec2, rotation: f32, size: Vec2, color: Color) {
+        self.rect(
+            position.extend(0.),
+            Quat::from_rotation_z(rotation),
+            size,
+            color,
+        );
     }
 
     pub fn clear(&mut self) {
-        self.debug_draw.clear();
+        self.positions.clear();
+        self.colors.clear();
+    }
+
+    pub fn update_mesh(&mut self, mesh: &mut Mesh) {
+        mesh.insert_attribute(
+            Mesh::ATTRIBUTE_POSITION,
+            std::mem::take(&mut self.positions),
+        );
+        mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, std::mem::take(&mut self.colors));
     }
 }
 
 #[derive(Component)]
 pub struct DebugDrawMesh;
 
 pub(crate) fn update(
-    mut draw: ResMut<DebugDrawResource>,
+    config: Res<DebugDrawConfig>,
+    mut debug_draw: ResMut<DebugDraw>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut commands: Commands,
 ) {
-    if let Some(mut mesh) = draw
+    if let Some(mut mesh) = debug_draw
         .mesh_handle
         .as_ref()
         .and_then(|handle| meshes.get_mut(handle))
     {
-        draw.update_mesh(&mut mesh);
-    } else {
+        if config.enabled {
+            debug_draw.update_mesh(&mut mesh);
+        } else {
+            debug_draw.clear();
+            mesh.remove_attribute(Mesh::ATTRIBUTE_POSITION);
+            mesh.remove_attribute(Mesh::ATTRIBUTE_COLOR);
+        }
+    } else if config.enabled {
         let mut mesh = Mesh::new(PrimitiveTopology::LineList);
-        draw.update_mesh(&mut mesh);
+        debug_draw.update_mesh(&mut mesh);
         let mesh_handle = meshes.add(mesh);
         commands.spawn((
             SpatialBundle::VISIBLE_IDENTITY,
             DebugDrawMesh,
-            #[cfg(feature = "3d")]
+            #[cfg(feature = "bevy_pbr")]
             (mesh_handle.clone_weak(), NotShadowCaster, NotShadowReceiver),
-            #[cfg(feature = "2d")]
+            #[cfg(feature = "bevy_sprite")]
             Mesh2dHandle(mesh_handle.clone_weak()),
         ));
-        draw.mesh_handle = Some(mesh_handle);
+        debug_draw.mesh_handle = Some(mesh_handle);
+    } else {
+        debug_draw.clear();
     }
 }
 

crates/bevy_internal/Cargo.toml

@@ -63,8 +63,8 @@ bevy_ci_testing = ["bevy_app/bevy_ci_testing", "bevy_render?/ci_limits"]
 # Enable animation support, and glTF animation loading
 animation = ["bevy_animation", "bevy_gltf?/bevy_animation"]
 
-bevy_sprite = ["dep:bevy_sprite", "bevy_debug_draw?/2d"]
-bevy_pbr = ["dep:bevy_pbr", "bevy_debug_draw?/3d"]
+bevy_sprite = ["dep:bevy_sprite", "bevy_debug_draw?/bevy_sprite"]
+bevy_pbr = ["dep:bevy_pbr", "bevy_debug_draw?/bevy_pbr"]
 
 [dependencies]
 # bevy