Change debug render systems to use bevy gizmos instead of bevy_polyline.

Cargo.toml

@@ -9,7 +9,6 @@ arrayvec = "0.7"
 async-trait = "0.1"
 bevy_egui = "0.21"
 bevy-inspector-egui = "0.19"
-bevy_polyline = "0.7"
 bevy_rapier3d = "0.22"
 bitflags = "2.3"
 bytemuck = { version = "1.7.0", features = ["derive"] }

src/lib.rs

@@ -77,7 +77,6 @@ use systems::{
     collision_player_system, collision_player_system_join_zoin, command_system,
     conversation_dialog_system, cooldown_system, damage_digit_render_system,
     debug_render_collider_system, debug_render_directional_light_system,
-    debug_render_polylines_setup_system, debug_render_polylines_update_system,
     debug_render_skeleton_system, directional_light_system, effect_system, facing_direction_system,
     free_camera_system, game_connection_system, game_mouse_input_system, game_state_enter_system,
     game_zone_change_system, hit_event_system, item_drop_model_add_collider_system,
@@ -474,6 +473,10 @@ fn run_client(config: &Config, app_state: AppState, mut systems_config: SystemsC
     // Initialise bevy engine
     app.insert_resource(Msaa::Off)
         .insert_resource(ClearColor(Color::rgb(0.70, 0.90, 1.0)))
+        .insert_resource(bevy::gizmos::GizmoConfig {
+            depth_bias: -0.1,
+            ..Default::default()
+        })
         .add_plugins((
             bevy::prelude::DefaultPlugins
                 .set(bevy::render::RenderPlugin {
@@ -524,7 +527,6 @@ fn run_client(config: &Config, app_state: AppState, mut systems_config: SystemsC
         ..Default::default()
     });
     app.add_plugins((
-        bevy_polyline::PolylinePlugin,
         bevy_egui::EguiPlugin,
         bevy_rapier3d::prelude::RapierPhysicsPlugin::<bevy_rapier3d::prelude::NoUserData>::default(
         ),
@@ -757,14 +759,12 @@ fn run_client(config: &Config, app_state: AppState, mut systems_config: SystemsC
     );
 
     // Run debug render stage last after physics update so it has accurate data
-    app.add_systems(Startup, debug_render_polylines_setup_system);
     app.add_systems(
         Update,
         (
-            debug_render_collider_system.before(debug_render_polylines_update_system),
-            debug_render_skeleton_system.before(debug_render_polylines_update_system),
-            debug_render_directional_light_system.before(debug_render_polylines_update_system),
-            debug_render_polylines_update_system,
+            debug_render_collider_system,
+            debug_render_skeleton_system,
+            debug_render_directional_light_system,
         )
             .in_set(GameStages::DebugRender),
     );

src/resources/debug_render.rs

@@ -1,8 +1,15 @@
-use bevy::{
-    math::Vec3,
-    prelude::{Entity, Handle, Resource},
-};
-use bevy_polyline::prelude::Polyline;
+use bevy::prelude::{Color, Entity, Resource};
+
+const DEBUG_RENDER_COLOR_LIST: [Color; 8] = [
+    Color::RED,
+    Color::GREEN,
+    Color::BLUE,
+    Color::YELLOW,
+    Color::CYAN,
+    Color::FUCHSIA,
+    Color::WHITE,
+    Color::BLACK,
+];
 
 #[derive(Default, Resource)]
 pub struct DebugRenderConfig {
@@ -13,25 +20,8 @@ pub struct DebugRenderConfig {
     pub directional_light_frustum_freeze: bool,
 }
 
-#[derive(Resource)]
-pub struct DebugRenderPolyline {
-    pub entity: Entity,
-    pub polyline: Handle<Polyline>,
-    pub vertices: Vec<Vec3>,
-}
-
-#[derive(Resource)]
-pub struct DebugRenderColliderData {
-    pub collider: Vec<DebugRenderPolyline>,
-}
-
-#[derive(Resource)]
-pub struct DebugRenderSkeletonData {
-    pub skeleton: DebugRenderPolyline,
-    pub bone_up: DebugRenderPolyline,
-}
-
-#[derive(Resource)]
-pub struct DebugRenderDirectionalLightData {
-    pub frustum: DebugRenderPolyline,
+impl DebugRenderConfig {
+    pub fn color_for_entity(&self, entity: Entity) -> Color {
+        DEBUG_RENDER_COLOR_LIST[entity.index() as usize % DEBUG_RENDER_COLOR_LIST.len()]
+    }
 }

src/resources/mod.rs

@@ -36,10 +36,7 @@ pub use client_entity_list::ClientEntityList;
 pub use current_zone::CurrentZone;
 pub use damage_digits_spawner::DamageDigitsSpawner;
 pub use debug_inspector::DebugInspector;
-pub use debug_render::{
-    DebugRenderColliderData, DebugRenderConfig, DebugRenderDirectionalLightData,
-    DebugRenderPolyline, DebugRenderSkeletonData,
-};
+pub use debug_render::DebugRenderConfig;
 pub use game_connection::GameConnection;
 pub use game_data::GameData;
 pub use login_connection::LoginConnection;

src/systems/debug_render_collider_system.rs

@@ -1,42 +1,24 @@
-use bevy::{
-    math::Vec3,
-    prelude::{Entity, GlobalTransform, Query, Res, ResMut},
-};
+use bevy::prelude::{Entity, Gizmos, GlobalTransform, Query, Res};
 use bevy_rapier3d::prelude::Collider;
 
-use crate::resources::{DebugRenderColliderData, DebugRenderConfig};
+use crate::resources::DebugRenderConfig;
 
 pub fn debug_render_collider_system(
     debug_render_config: Res<DebugRenderConfig>,
     query_colliders: Query<(Entity, &Collider, &GlobalTransform)>,
-    mut render_data: ResMut<DebugRenderColliderData>,
+    mut gizmos: Gizmos,
 ) {
     if !debug_render_config.colliders {
         return;
     }
 
     for (entity, collider, global_transform) in query_colliders.iter() {
-        let line_index = entity.index() as usize % render_data.collider.len();
-        let line_data = &mut render_data.collider[line_index];
-
-        // The collider shape has already been scaled
-        let mut transform = global_transform.compute_transform();
-        transform.scale = Vec3::ONE;
-
         if let Some(cuboid) = collider.as_cuboid() {
-            let (vertices, indices) = cuboid.raw.to_outline();
-
-            for idx in indices {
-                line_data
-                    .vertices
-                    .push(transform.transform_point(vertices[idx[0] as usize].into()));
-                line_data
-                    .vertices
-                    .push(transform.transform_point(vertices[idx[1] as usize].into()));
-                line_data
-                    .vertices
-                    .push(Vec3::new(f32::NAN, f32::NAN, f32::NAN));
-            }
+            let transform = global_transform
+                .compute_transform()
+                .with_scale(cuboid.half_extents() * 2.0);
+            let color = debug_render_config.color_for_entity(entity);
+            gizmos.cuboid(transform, color);
         }
     }
 }

src/systems/debug_render_directional_light_system.rs

@@ -1,9 +1,9 @@
 use bevy::{
-    prelude::{DirectionalLight, Local, Query, Res, ResMut, Vec3, With},
+    prelude::{Color, DirectionalLight, Gizmos, Local, Query, Res, Vec3, With},
     render::primitives::{CascadesFrusta, Frustum, HalfSpace},
 };
 
-use crate::resources::{DebugRenderConfig, DebugRenderDirectionalLightData};
+use crate::resources::DebugRenderConfig;
 
 fn calculate_frustum_corner(plane1: &HalfSpace, plane2: &HalfSpace, plane3: &HalfSpace) -> Vec3 {
     let denominator = plane1.normal().dot(plane2.normal().cross(plane3.normal()));
@@ -41,8 +41,8 @@ fn calculate_frustum_corners(frustum: &Frustum) -> [Vec3; 8] {
 pub fn debug_render_directional_light_system(
     debug_render_config: Res<DebugRenderConfig>,
     query_cascades_frustum: Query<&CascadesFrusta, With<DirectionalLight>>,
-    mut render_data: ResMut<DebugRenderDirectionalLightData>,
     mut last_cascades_frusta: Local<CascadesFrusta>,
+    mut gizmos: Gizmos,
 ) {
     if !debug_render_config.directional_light_frustum {
         return;
@@ -54,35 +54,23 @@ pub fn debug_render_directional_light_system(
         }
     }
 
-    render_data.frustum.vertices.clear();
-
     for (_, frusta) in last_cascades_frusta.frusta.iter() {
         for frustum in frusta.iter() {
             let corners = calculate_frustum_corners(frustum);
-            render_data.frustum.vertices.push(corners[0]);
-            render_data.frustum.vertices.push(corners[2]);
-            render_data.frustum.vertices.push(corners[6]);
-            render_data.frustum.vertices.push(corners[4]);
-            render_data.frustum.vertices.push(corners[0]);
-            render_data.frustum.vertices.push(Vec3::NAN);
-            render_data.frustum.vertices.push(corners[1]);
-            render_data.frustum.vertices.push(corners[3]);
-            render_data.frustum.vertices.push(corners[7]);
-            render_data.frustum.vertices.push(corners[5]);
-            render_data.frustum.vertices.push(corners[1]);
-            render_data.frustum.vertices.push(Vec3::NAN);
-            render_data.frustum.vertices.push(corners[0]);
-            render_data.frustum.vertices.push(corners[1]);
-            render_data.frustum.vertices.push(Vec3::NAN);
-            render_data.frustum.vertices.push(corners[2]);
-            render_data.frustum.vertices.push(corners[3]);
-            render_data.frustum.vertices.push(Vec3::NAN);
-            render_data.frustum.vertices.push(corners[4]);
-            render_data.frustum.vertices.push(corners[5]);
-            render_data.frustum.vertices.push(Vec3::NAN);
-            render_data.frustum.vertices.push(corners[6]);
-            render_data.frustum.vertices.push(corners[7]);
-            render_data.frustum.vertices.push(Vec3::NAN);
+
+            gizmos.linestrip(
+                [corners[0], corners[2], corners[6], corners[4], corners[0]],
+                Color::YELLOW_GREEN,
+            );
+            gizmos.linestrip(
+                [corners[1], corners[3], corners[7], corners[5], corners[1]],
+                Color::YELLOW_GREEN,
+            );
+
+            gizmos.line(corners[0], corners[1], Color::YELLOW_GREEN);
+            gizmos.line(corners[2], corners[3], Color::YELLOW_GREEN);
+            gizmos.line(corners[4], corners[5], Color::YELLOW_GREEN);
+            gizmos.line(corners[6], corners[7], Color::YELLOW_GREEN);
         }
     }
 }