From f77bda7f850486087539fa92ea56ca3c8b69aaa9 Mon Sep 17 00:00:00 2001
From: Aceeri <conmcclusk@gmail.com>
Date: Fri, 12 Jul 2024 15:38:25 -0700
Subject: [PATCH 1/2] Bevy 0.14

---
 Cargo.toml               |  17 +++----
 examples/first_person.rs |  76 +++++++++++------------------
 examples/playground.rs   | 102 ++++++++++++++++++---------------------
 examples/starship.rs     |  13 +++--
 src/bundles.rs           |   6 +--
 src/controller/ground.rs |  52 ++++++++++++--------
 src/plugins.rs           |  10 ++--
 7 files changed, 129 insertions(+), 147 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4852f52..dd8e0d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,21 +18,21 @@ debug_lines = []
 rapier = ["bevy_rapier3d"]
 
 [dependencies]
-bevy = { version = "0.11", default-features = false, features = [
+bevy = { version = "0.14", default-features = false, features = [
     "bevy_render",
     "bevy_gizmos",
 ] }
-bevy_rapier3d = { version = "0.22", default-features = false, features = [
+bevy_rapier3d = { version = "0.27", default-features = false, features = [
     "async-collider",
     "dim3",
 ], optional = true }
 
 [dev-dependencies]
-bevy = "0.11"
-aether_spyglass = "0.2"
-bevy-inspector-egui = "0.19"
-bevy_framepace = "0.13"
-bevy_rapier3d = { version = "0.22", features = ["debug-render"] }
+bevy = "0.14"
+#aether_spyglass = "0.2"
+bevy-inspector-egui = "0.25"
+bevy_framepace = "0.17"
+bevy_rapier3d = { version = "0.27", features = ["debug-render"] }
 
 # Enable a small amount of optimization in debug mode
 [profile.dev]
@@ -43,5 +43,4 @@ opt-level = 1
 opt-level = 3
 
 [patch.crates-io]
-#bevy_rapier3d = { path = "../bevy_rapier/bevy_rapier3d" }
-bevy_rapier3d = { git = "https://github.com/dimforge/bevy_rapier", rev = "0ea000b" }
\ No newline at end of file
+#bevy_rapier3d = { path = "../bevy_rapier/bevy_rapier3d" }
\ No newline at end of file
diff --git a/examples/first_person.rs b/examples/first_person.rs
index aa8c9fa..5fcd442 100644
--- a/examples/first_person.rs
+++ b/examples/first_person.rs
@@ -6,6 +6,7 @@ use bevy::{
     input::mouse::MouseMotion,
     prelude::*,
     window::{Cursor, PrimaryWindow},
+    color::palettes::css,
 };
 use bevy_framepace::{FramepacePlugin, FramepaceSettings, Limiter};
 use bevy_mod_wanderlust::{
@@ -30,11 +31,11 @@ fn main() {
                 ..default()
             }),
             RapierPhysicsPlugin::<NoUserData>::default(),
+            bevy_inspector_egui::quick::WorldInspectorPlugin::default(),
             // This plugin was causing unhelpful glitchy orange planes, so it's commented out until
             // it's working again
-            // RapierDebugRenderPlugin::default(),
+            RapierDebugRenderPlugin::default(),
             WanderlustPlugin::default(),
-            aether_spyglass::SpyglassPlugin,
             FramepacePlugin,
         ))
         .insert_resource(RapierConfiguration {
@@ -42,7 +43,7 @@ fn main() {
                 dt: 0.008,
                 substeps: 4,
             },
-            ..default()
+            ..RapierConfiguration::new(1.0)
         })
         .insert_resource(FramepaceSettings {
             limiter: Limiter::Manual(std::time::Duration::from_secs_f64(0.008)),
@@ -58,7 +59,7 @@ fn main() {
                 toggle_cursor_lock,
             ),
         )
-        .run()
+        .run();
 }
 
 #[derive(Component, Default, Reflect)]
@@ -78,15 +79,14 @@ fn setup(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let mesh = meshes.add(
-        shape::Capsule {
+        Capsule3d {
             radius: 0.5,
-            depth: 1.0,
+            half_length: 0.5, 
             ..default()
         }
-        .into(),
     );
 
-    let material = mats.add(Color::WHITE.into());
+    let material = mats.add(Color::from(css::WHITE));
 
     commands
         .spawn((
@@ -127,7 +127,7 @@ fn setup(
                     PlayerCam,
                 ))
                 .with_children(|commands| {
-                    let mesh = meshes.add(shape::Cube { size: 0.5 }.into());
+                    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(0.25), });
 
                     commands.spawn(PbrBundle {
                         mesh,
@@ -138,13 +138,7 @@ fn setup(
                 });
         });
 
-    let mesh = meshes.add(
-        shape::Plane {
-            size: 10.0,
-            ..default()
-        }
-        .into(),
-    );
+    let mesh = meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(5.0)));
 
     commands.spawn((
         PbrBundle {
@@ -163,17 +157,9 @@ fn setup(
     });
 
     let (hw, hh, hl) = (1.5, 0.5, 5.0);
-    let mesh = meshes.add(
-        shape::Box {
-            min_x: -hw,
-            max_x: hw,
-            min_y: -hh,
-            max_y: hh,
-            min_z: -hl,
-            max_z: hl,
-        }
-        .into(),
-    );
+    let min = Vec3::new(-hw, -hh, -hl);
+    let max = Vec3::new(hw, hh, hl);
+    let mesh = meshes.add( Cuboid::from_corners(min, max));
 
     commands.spawn((
         PbrBundle {
@@ -192,17 +178,9 @@ fn setup(
     ));
 
     let (hw, hh, hl) = (0.25, 3.0, 5.0);
-    let mesh = meshes.add(
-        shape::Box {
-            min_x: -hw,
-            max_x: hw,
-            min_y: -hh,
-            max_y: hh,
-            min_z: -hl,
-            max_z: hl,
-        }
-        .into(),
-    );
+    let min = Vec3::new(-hw, -hh, -hl);
+    let max = Vec3::new(hw, hh, hl);
+    let mesh = meshes.add( Cuboid::from_corners(min, max));
 
     commands.spawn((
         PbrBundle {
@@ -235,24 +213,24 @@ fn setup(
 fn movement_input(
     mut body: Query<&mut ControllerInput, With<PlayerBody>>,
     camera: Query<&GlobalTransform, (With<PlayerCam>, Without<PlayerBody>)>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
 ) {
     let tf = camera.single();
 
     let mut player_input = body.single_mut();
 
     let mut dir = Vec3::ZERO;
-    if input.pressed(KeyCode::A) {
-        dir += -tf.right();
+    if input.pressed(KeyCode::KeyA) {
+        dir += -tf.right().as_vec3();
     }
-    if input.pressed(KeyCode::D) {
-        dir += tf.right();
+    if input.pressed(KeyCode::KeyD) {
+        dir += tf.right().as_vec3();
     }
-    if input.pressed(KeyCode::S) {
-        dir += -tf.forward();
+    if input.pressed(KeyCode::KeyS) {
+        dir += -tf.forward().as_vec3();
     }
-    if input.pressed(KeyCode::W) {
-        dir += tf.forward();
+    if input.pressed(KeyCode::KeyW) {
+        dir += tf.forward().as_vec3();
     }
     dir.y = 0.0;
     player_input.movement = dir.normalize_or_zero();
@@ -271,7 +249,7 @@ fn mouse_look(
 
     let sens = sensitivity.0;
 
-    let mut cumulative: Vec2 = -(input.iter().map(|motion| &motion.delta).sum::<Vec2>());
+    let mut cumulative: Vec2 = -(input.read().map(|motion| &motion.delta).sum::<Vec2>());
 
     // Vertical
     let rot = cam_tf.rotation;
@@ -295,7 +273,7 @@ fn mouse_look(
 }
 
 fn toggle_cursor_lock(
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut windows: Query<&mut Window, With<PrimaryWindow>>,
 ) {
     if input.just_pressed(KeyCode::Escape) {
diff --git a/examples/playground.rs b/examples/playground.rs
index 1c81f54..ecf3e4f 100644
--- a/examples/playground.rs
+++ b/examples/playground.rs
@@ -6,6 +6,7 @@ use bevy::{
     input::mouse::MouseMotion,
     prelude::*,
     window::{Cursor, PrimaryWindow},
+    color::palettes::css,
 };
 use bevy_framepace::*;
 use bevy_mod_wanderlust::{
@@ -16,7 +17,7 @@ use bevy_mod_wanderlust::{
 use bevy_rapier3d::prelude::*;
 use std::f32::consts::{FRAC_2_PI, PI};
 
-fn main() {
+fn main() -> AppExit {
     App::new()
         .add_plugins((
             DefaultPlugins.set(WindowPlugin {
@@ -43,7 +44,7 @@ fn main() {
                 dt: 0.016,
                 substeps: 32,
             },
-            ..default()
+            ..RapierConfiguration::new(1.0)
         })
         .insert_resource(FramepaceSettings {
             limiter: Limiter::Manual(std::time::Duration::from_secs_f64(0.016)),
@@ -65,16 +66,16 @@ fn main() {
         )
         .add_systems(
             Last,
-            |input: Res<Input<KeyCode>>,
+            |input: Res<ButtonInput<KeyCode>>,
              //mut freeze: ResMut<Freeze>,
              mut freeze: Local<bool>,
              mut time: ResMut<Time>,
              mut rapier_config: ResMut<RapierConfiguration>| {
-                if input.just_pressed(KeyCode::R) {
+                if input.just_pressed(KeyCode::KeyR) {
                     *freeze = !*freeze;
                 }
 
-                if !*freeze || input.just_pressed(KeyCode::F) {
+                if !*freeze || input.just_pressed(KeyCode::KeyF) {
                     rapier_config.timestep_mode = TimestepMode::Fixed {
                         dt: 0.016,
                         substeps: 32,
@@ -104,8 +105,8 @@ fn main() {
         )
         .add_systems(
             Update,
-            |input: Res<Input<KeyCode>>, mut impulses: Query<&mut ExternalImpulse>| {
-                if !input.just_pressed(KeyCode::P) {
+            |input: Res<ButtonInput<KeyCode>>, mut impulses: Query<&mut ExternalImpulse>| {
+                if !input.just_pressed(KeyCode::KeyP) {
                     return;
                 }
 
@@ -137,15 +138,13 @@ pub fn player(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let mesh = meshes.add(
-        shape::Capsule {
+        Capsule3d {
             radius: 0.3,
-            depth: 1.0,
-            ..default()
+            half_length: 0.5,
         }
-        .into(),
     );
 
-    let material = mats.add(Color::WHITE.into());
+    let material = mats.add(Color::from(css::WHITE));
 
     let player = commands
         .spawn((
@@ -224,7 +223,7 @@ pub fn player(
                     ..default()
                 },))
                 .with_children(|commands| {
-                    let mesh = meshes.add(shape::Cube { size: 0.5 }.into());
+                    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(0.25) });
 
                     commands.spawn(PbrBundle {
                         mesh,
@@ -241,13 +240,11 @@ pub fn free_objects(
     mut meshes: ResMut<Assets<Mesh>>,
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
-    let material = mats.add(Color::WHITE.into());
+    let material = mats.add(Color::from(css::WHITE));
     let mesh = meshes.add(
-        shape::UVSphere {
+        Sphere {
             radius: 0.5,
-            ..default()
         }
-        .into(),
     );
     commands.spawn((
         PbrBundle {
@@ -270,15 +267,14 @@ pub fn ground(
     mut meshes: ResMut<Assets<Mesh>>,
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
-    let material = mats.add(Color::BLACK.into());
+    let material = mats.add(Color::from(css::BLACK));
 
     let size = 1000.0;
     let mesh = meshes.add(
-        shape::Plane {
-            size: size,
+        Plane3d {
+            half_size: Vec2::splat(size / 2.0),
             ..default()
         }
-        .into(),
     );
 
     commands.spawn((
@@ -289,24 +285,18 @@ pub fn ground(
             ..default()
         },
         Collider::halfspace(Vec3::Y).unwrap(),
-        ColliderDebugColor(Color::Rgba {
+        ColliderDebugColor(Srgba {
             red: 0.0,
             green: 0.0,
             blue: 0.0,
             alpha: 0.0,
-        }),
+        }.into()),
         //Collider::cuboid(size / 2.0, 0.1, size / 2.0),
         Name::from("Ground"),
     ));
 
-    let material = mats.add(Color::WHITE.into());
-    let mesh = meshes.add(
-        shape::UVSphere {
-            radius: 0.5,
-            ..default()
-        }
-        .into(),
-    );
+    let material = mats.add(Color::from(css::WHITE));
+    let mesh = meshes.add( Sphere::new(0.5));
     commands.spawn((
         PbrBundle {
             mesh,
@@ -349,13 +339,13 @@ pub fn stairs(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let material = mats.add(StandardMaterial {
-        base_color: Color::PINK,
+        base_color: Color::from(css::PINK),
         perceptual_roughness: 0.5,
         reflectance: 0.05,
         ..default()
     });
 
-    let mesh = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
+    let mesh = meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5) }));
     steps(
         Transform {
             translation: Vec3::new(5.0, 0.0, -5.0),
@@ -430,12 +420,12 @@ pub fn walls(
     mut meshes: ResMut<Assets<Mesh>>,
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
-    let materials = [Color::GRAY, Color::WHITE, Color::BLACK];
+    let materials = [css::GRAY, css::WHITE, css::BLACK];
     let materials = materials
         .iter()
         .map(|color| {
             mats.add(StandardMaterial {
-                base_color: *color,
+                base_color: (*color).into(),
                 perceptual_roughness: 0.5,
                 reflectance: 0.05,
                 ..default()
@@ -461,7 +451,7 @@ pub fn walls(
         commands
             .spawn((
                 PbrBundle {
-                    mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                    mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
                     material: material,
                     transform: Transform {
                         translation: Vec3::new(0.0, 0.0, part as f32 * width),
@@ -479,7 +469,7 @@ pub fn walls(
     commands
         .spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
                 material: materials[0].clone(),
                 transform: Transform {
                     translation: Vec3::new(0.0, 0.0, ((parts + 1) as f32 * width) * 1.5),
@@ -500,7 +490,7 @@ pub fn slopes(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let material = mats.add(StandardMaterial {
-        base_color: Color::GREEN,
+        base_color: css::GREEN.into(),
         perceptual_roughness: 0.5,
         reflectance: 0.05,
         ..default()
@@ -516,7 +506,7 @@ pub fn slopes(
         let rotation_diff = width * radians;
         commands.spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
                 material: material.clone(),
                 transform: Transform {
                     translation: Vec3::new(rotation_diff, 0.0, angle as f32 * width + width * 2.0),
@@ -531,7 +521,7 @@ pub fn slopes(
 
         commands.spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
                 material: material.clone(),
                 transform: Transform {
                     translation: Vec3::new(
@@ -556,18 +546,18 @@ pub fn moving_objects(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let material = mats.add(StandardMaterial {
-        base_color: Color::YELLOW,
+        base_color: css::YELLOW.into(),
         perceptual_roughness: 0.5,
         reflectance: 0.05,
         ..default()
     });
-    let mesh = meshes.add(Mesh::from(shape::Cube::default()));
+    let mesh = meshes.add(Mesh::from(Cuboid::default()));
 
     // simple
     let simple_width = 3.0;
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
             material: material.clone(),
             transform: Transform {
                 translation: Vec3::new(-5.0, 0.3, 10.0),
@@ -590,7 +580,7 @@ pub fn moving_objects(
     let simple_width = 3.0;
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            mesh: meshes.add(Mesh::from(Cuboid::default())),
             material: material.clone(),
             transform: Transform {
                 translation: Vec3::new(-10.0, 0.3, 10.0),
@@ -614,7 +604,7 @@ pub fn moving_objects(
     let simple_width = 3.0;
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5) })),
             material: material.clone(),
             transform: Transform {
                 translation: Vec3::new(-5.0, 0.3, 10.0),
@@ -651,19 +641,19 @@ impl Default for Oscillator {
 }
 
 pub fn controlled_platform(
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut controlled: Query<(&mut Velocity, &Controlled)>,
 ) {
     for (mut velocity, _) in &mut controlled {
-        if input.pressed(KeyCode::H) {
+        if input.pressed(KeyCode::KeyH) {
             velocity.linvel.x = 0.0;
         }
 
-        if input.pressed(KeyCode::N) {
+        if input.pressed(KeyCode::KeyN) {
             velocity.linvel.x = 5.0;
         }
 
-        if input.pressed(KeyCode::M) {
+        if input.pressed(KeyCode::KeyM) {
             velocity.linvel.x = -5.0;
         }
     }
@@ -683,7 +673,7 @@ pub fn oscillating(time: Res<Time>, mut oscillators: Query<(&mut Velocity, &Osci
 fn movement_input(
     mut body: Query<(&mut ControllerInput, &mut Movement), With<PlayerBody>>,
     camera: Query<&PlayerCam>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
 ) {
     let camera = camera.single();
     let camera_dir = Quat::from_rotation_y(camera.yaw);
@@ -699,16 +689,16 @@ fn movement_input(
     }
 
     let mut dir = Vec3::ZERO;
-    if input.pressed(KeyCode::A) {
+    if input.pressed(KeyCode::KeyA) {
         dir += -right;
     }
-    if input.pressed(KeyCode::D) {
+    if input.pressed(KeyCode::KeyD) {
         dir += right;
     }
-    if input.pressed(KeyCode::S) {
+    if input.pressed(KeyCode::KeyS) {
         dir += -forward;
     }
-    if input.pressed(KeyCode::W) {
+    if input.pressed(KeyCode::KeyW) {
         dir += forward;
     }
     dir.y = 0.0;
@@ -731,7 +721,7 @@ fn mouse_look(
     let mut upright = upright.single_mut();
 
     let sens = sensitivity.0;
-    let cumulative: Vec2 = -(input.iter().map(|motion| &motion.delta).sum::<Vec2>());
+    let cumulative: Vec2 = -(input.read().map(|motion| &motion.delta).sum::<Vec2>());
     player_cam.pitch += cumulative.y as f32 / 180.0 * sens;
     player_cam.yaw += cumulative.x as f32 / 180.0 * sens;
 
@@ -747,7 +737,7 @@ fn mouse_look(
 }
 
 fn toggle_cursor_lock(
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut windows: Query<&mut Window, With<PrimaryWindow>>,
 ) {
     if input.just_pressed(KeyCode::Escape) {
diff --git a/examples/starship.rs b/examples/starship.rs
index 986b9ea..bf86efc 100644
--- a/examples/starship.rs
+++ b/examples/starship.rs
@@ -1,8 +1,11 @@
 use std::f32::consts::FRAC_PI_2;
 
-use bevy::input::mouse::MouseMotion;
-use bevy::prelude::*;
-use bevy::window::{Cursor, CursorGrabMode, PrimaryWindow};
+use bevy::{
+    input::mouse::MouseMotion,
+    prelude::*,
+    window::{Cursor, CursorGrabMode, PrimaryWindow},
+    color::palettes::css,
+};
 use bevy_mod_wanderlust::{
     ControllerBundle, ControllerInput, ControllerPhysicsBundle, WanderlustPlugin,
 };
@@ -50,8 +53,8 @@ fn setup(
     ass: Res<AssetServer>,
 ) {
     // Origin cube to be able to tell how you're moving
-    let mesh = meshes.add(shape::Cube { size: 10.0 }.into());
-    let material = mats.add(Color::WHITE.into());
+    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(5.0) }.into());
+    let material = mats.add(Color::from(css::WHITE));
 
     c.spawn(PbrBundle {
         mesh,
diff --git a/src/bundles.rs b/src/bundles.rs
index 8af59c0..5ce0b4b 100644
--- a/src/bundles.rs
+++ b/src/bundles.rs
@@ -22,8 +22,8 @@ pub struct ControllerBundle {
     pub global_transform: GlobalTransform,
     /// See [`Visibility`]
     pub visibility: Visibility,
-    /// See [`ComputedVisibility`]
-    pub computed_visibility: ComputedVisibility,
+    /// See [`IinheritedVisibility`]
+    pub inherited_visibility: InheritedVisibility,
 }
 
 impl Default for ControllerBundle {
@@ -37,7 +37,7 @@ impl Default for ControllerBundle {
             transform: default(),
             global_transform: default(),
             visibility: default(),
-            computed_visibility: default(),
+            inherited_visibility: default(),
         }
     }
 }
diff --git a/src/controller/ground.rs b/src/controller/ground.rs
index ca8b252..c5765f4 100644
--- a/src/controller/ground.rs
+++ b/src/controller/ground.rs
@@ -1,5 +1,5 @@
 use crate::controller::*;
-use bevy::utils::HashSet;
+use bevy::{color::palettes::css, utils::HashSet};
 use bevy_rapier3d::{
     na::Isometry3,
     parry::{
@@ -357,7 +357,7 @@ pub fn find_ground(
         */
 
         // If we hit something, just get back up instead of waiting.
-        if ctx.contacts_with(entity).next().is_some() {
+        if ctx.contact_pairs_with(entity).next().is_some() {
             caster.skip_ground_check_timer = 0.0;
         }
     }
@@ -381,8 +381,8 @@ pub fn determine_groundedness(
             let translation = global.translation();
             let updated_toi =
                 translation.dot(gravity.up_vector) - ground.cast.point.dot(gravity.up_vector);
-            //gizmos.sphere(ground.cast.point, Quat::IDENTITY, 0.3, Color::RED);
-            //gizmos.sphere(translation, Quat::IDENTITY, 0.3, Color::GREEN);
+            //gizmos.sphere(ground.cast.point, Quat::IDENTITY, 0.3, css::RED.into());
+            //gizmos.sphere(translation, Quat::IDENTITY, 0.3, css::GREEN.into());
             let offset = float.distance - updated_toi;
 
             //let up_velocity = up_velocity.clamp(-float.distance, float.distance);
@@ -436,18 +436,18 @@ impl CastResult {
 
 impl CastResult {
     /// Use the first shape in the shape-cast as the cast result.
-    pub fn from_toi1(toi: Toi) -> Option<Self> {
+    pub fn from_toi1(toi: ShapeCastHit) -> Option<Self> {
         toi.details.map(|details| Self {
-            toi: toi.toi,
+            toi: toi.time_of_impact,
             normal: details.normal1,
             point: details.witness1,
         })
     }
 
     /// Use the second shape in the shape-cast as the cast result.
-    pub fn from_toi2(toi: Toi) -> Option<Self> {
+    pub fn from_toi2(toi: ShapeCastHit) -> Option<Self> {
         toi.details.map(|details| Self {
-            toi: toi.toi,
+            toi: toi.time_of_impact,
             normal: details.normal2,
             point: details.witness2,
         })
@@ -457,7 +457,7 @@ impl CastResult {
 impl From<RayIntersection> for CastResult {
     fn from(intersection: RayIntersection) -> Self {
         Self {
-            toi: intersection.toi,
+            toi: intersection.time_of_impact,
             normal: intersection.normal,
             point: intersection.point,
         }
@@ -472,7 +472,7 @@ pub fn contact_manifolds(
     collider: &Collider,
     filter: &QueryFilter,
 ) -> Vec<(Entity, ContactManifold)> {
-    let physics_scale = ctx.physics_scale();
+    let physics_scale = ctx.integration_parameters.length_unit;
 
     let shape = &collider.raw;
     let shape_iso = Isometry3 {
@@ -657,14 +657,17 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
             self.rotation,
             self.direction,
             self.shape,
-            self.max_toi,
-            true,
+            ShapeCastOptions {
+                max_time_of_impact: self.max_toi,
+                stop_at_penetration: true,
+                ..default()
+            },
             self.filter,
         ) else {
             return None;
         };
 
-        if toi.toi <= std::f32::EPSILON {
+        if toi.time_of_impact <= std::f32::EPSILON {
             return None;
         }
 
@@ -673,12 +676,16 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
             return None;
         };
 
-        gizmos.ray(self.position, self.direction * cast.toi, Color::BLUE);
+        gizmos.ray(
+            self.position,
+            self.direction * cast.toi,
+            Color::from(css::BLUE),
+        );
         gizmos.sphere(
             self.position + self.direction * cast.toi,
             self.rotation,
             0.3,
-            Color::BLUE,
+            Color::from(css::BLUE),
         );
 
         Some((entity, cast))
@@ -715,7 +722,7 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
         self.direction = down_tangent.normalize_or_zero();
         self.position = projected_position;
 
-        gizmos.ray(cast.point, down_tangent * 0.3, Color::CYAN);
+        gizmos.ray(cast.point, down_tangent * 0.3, Color::from(css::LIGHT_BLUE));
         self.max_toi -= cast.toi;
         //max_toi -= (toi.toi - offset).max(0.0);
         self.max_toi = self.max_toi.max(0.0);
@@ -744,7 +751,12 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
         // for the closest normal
         let mut sampled = Vec::new();
         let valid_radius = FUDGE * 2.0;
-        gizmos.sphere(cast.point, Quat::IDENTITY, valid_radius, Color::RED); // Bounding sphere of valid ray normals
+        gizmos.sphere(
+            cast.point,
+            Quat::IDENTITY,
+            valid_radius,
+            Color::from(css::RED),
+        ); // Bounding sphere of valid ray normals
         for sample in samples {
             let Some((_, inter)) = ctx.cast_ray_and_get_normal(
                 ray_origin - sample * FUDGE,
@@ -756,11 +768,11 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
                 continue;
             };
 
-            if inter.toi > 0.0
+            if inter.time_of_impact > 0.0
                 && inter.normal.length_squared() > 0.0
                 && inter.point.distance(cast.point) < valid_radius
             {
-                gizmos.ray(inter.point, inter.normal * 0.2, Color::RED);
+                gizmos.ray(inter.point, inter.normal * 0.2, Color::from(css::RED));
                 sampled.push(inter.normal);
             }
         }
@@ -773,7 +785,7 @@ impl<'c, 'f> GroundCastParams<'c, 'f> {
             weights += alignment;
         }
         let weighted_average = sum / weights;
-        gizmos.ray(cast.point, weighted_average * 0.5, Color::MAROON);
+        gizmos.ray(cast.point, weighted_average * 0.5, Color::from(css::MAROON));
 
         if weighted_average.length_squared() > 0.0 {
             Some(weighted_average)
diff --git a/src/plugins.rs b/src/plugins.rs
index c00dec6..8ccb435 100644
--- a/src/plugins.rs
+++ b/src/plugins.rs
@@ -1,12 +1,12 @@
 use crate::controller::*;
-use bevy::{ecs::schedule::ScheduleLabel, prelude::*, utils::HashSet};
+use bevy::{ecs::{intern::Interned, schedule::ScheduleLabel}, prelude::*, utils::HashSet};
 use bevy_rapier3d::prelude::*;
 
 /// The [character controller](CharacterController) plugin. Necessary to have the character controller
 /// work.
 pub struct WanderlustPlugin {
     tweaks: bool,
-    schedule: Box<dyn ScheduleLabel>,
+    schedule: Interned<dyn ScheduleLabel>,
     default_system_setup: bool,
 }
 
@@ -33,7 +33,7 @@ impl WanderlustPlugin {
 
     /// Adds the controller systems to the provided schedule rather than `Update`.
     pub fn in_schedule(mut self, schedule: impl ScheduleLabel) -> Self {
-        self.schedule = Box::new(schedule);
+        self.schedule = schedule.intern();
         self
     }
 }
@@ -42,7 +42,7 @@ impl Default for WanderlustPlugin {
     fn default() -> Self {
         Self {
             tweaks: true,
-            schedule: Box::new(PostUpdate),
+            schedule: PostUpdate.intern(),
             default_system_setup: true,
         }
     }
@@ -102,7 +102,7 @@ impl Plugin for WanderlustPlugin {
             );
         }
 
-        #[cfg(feature = "debug-lines")]
+        #[cfg(feature = "debug_lines")]
         app.add_systems(Update, |casts: Query<&GroundCast>, mut gizmos: Gizmos| {
             for cast in &casts {
                 if let Some((entity, toi, velocity)) = cast.cast {

From 60fd24e637386d2f4b519487a78c4197e2332704 Mon Sep 17 00:00:00 2001
From: Aceeri <conmcclusk@gmail.com>
Date: Fri, 12 Jul 2024 15:43:46 -0700
Subject: [PATCH 2/2] Formatting

---
 examples/first_person.rs | 22 ++++++------
 examples/playground.rs   | 77 +++++++++++++++++++++++-----------------
 examples/starship.rs     |  9 +++--
 src/plugins.rs           |  6 +++-
 4 files changed, 67 insertions(+), 47 deletions(-)

diff --git a/examples/first_person.rs b/examples/first_person.rs
index 5fcd442..442043b 100644
--- a/examples/first_person.rs
+++ b/examples/first_person.rs
@@ -3,10 +3,10 @@
 use bevy::render::camera::Projection;
 use bevy::window::CursorGrabMode;
 use bevy::{
+    color::palettes::css,
     input::mouse::MouseMotion,
     prelude::*,
     window::{Cursor, PrimaryWindow},
-    color::palettes::css,
 };
 use bevy_framepace::{FramepacePlugin, FramepaceSettings, Limiter};
 use bevy_mod_wanderlust::{
@@ -78,13 +78,11 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
-    let mesh = meshes.add(
-        Capsule3d {
-            radius: 0.5,
-            half_length: 0.5, 
-            ..default()
-        }
-    );
+    let mesh = meshes.add(Capsule3d {
+        radius: 0.5,
+        half_length: 0.5,
+        ..default()
+    });
 
     let material = mats.add(Color::from(css::WHITE));
 
@@ -127,7 +125,9 @@ fn setup(
                     PlayerCam,
                 ))
                 .with_children(|commands| {
-                    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(0.25), });
+                    let mesh = meshes.add(Cuboid {
+                        half_size: Vec3::splat(0.25),
+                    });
 
                     commands.spawn(PbrBundle {
                         mesh,
@@ -159,7 +159,7 @@ fn setup(
     let (hw, hh, hl) = (1.5, 0.5, 5.0);
     let min = Vec3::new(-hw, -hh, -hl);
     let max = Vec3::new(hw, hh, hl);
-    let mesh = meshes.add( Cuboid::from_corners(min, max));
+    let mesh = meshes.add(Cuboid::from_corners(min, max));
 
     commands.spawn((
         PbrBundle {
@@ -180,7 +180,7 @@ fn setup(
     let (hw, hh, hl) = (0.25, 3.0, 5.0);
     let min = Vec3::new(-hw, -hh, -hl);
     let max = Vec3::new(hw, hh, hl);
-    let mesh = meshes.add( Cuboid::from_corners(min, max));
+    let mesh = meshes.add(Cuboid::from_corners(min, max));
 
     commands.spawn((
         PbrBundle {
diff --git a/examples/playground.rs b/examples/playground.rs
index ecf3e4f..2de92d4 100644
--- a/examples/playground.rs
+++ b/examples/playground.rs
@@ -3,10 +3,10 @@
 use bevy::render::camera::Projection;
 use bevy::window::CursorGrabMode;
 use bevy::{
+    color::palettes::css,
     input::mouse::MouseMotion,
     prelude::*,
     window::{Cursor, PrimaryWindow},
-    color::palettes::css,
 };
 use bevy_framepace::*;
 use bevy_mod_wanderlust::{
@@ -137,12 +137,10 @@ pub fn player(
     mut meshes: ResMut<Assets<Mesh>>,
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
-    let mesh = meshes.add(
-        Capsule3d {
-            radius: 0.3,
-            half_length: 0.5,
-        }
-    );
+    let mesh = meshes.add(Capsule3d {
+        radius: 0.3,
+        half_length: 0.5,
+    });
 
     let material = mats.add(Color::from(css::WHITE));
 
@@ -223,7 +221,9 @@ pub fn player(
                     ..default()
                 },))
                 .with_children(|commands| {
-                    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(0.25) });
+                    let mesh = meshes.add(Cuboid {
+                        half_size: Vec3::splat(0.25),
+                    });
 
                     commands.spawn(PbrBundle {
                         mesh,
@@ -241,11 +241,7 @@ pub fn free_objects(
     mut mats: ResMut<Assets<StandardMaterial>>,
 ) {
     let material = mats.add(Color::from(css::WHITE));
-    let mesh = meshes.add(
-        Sphere {
-            radius: 0.5,
-        }
-    );
+    let mesh = meshes.add(Sphere { radius: 0.5 });
     commands.spawn((
         PbrBundle {
             mesh,
@@ -270,12 +266,10 @@ pub fn ground(
     let material = mats.add(Color::from(css::BLACK));
 
     let size = 1000.0;
-    let mesh = meshes.add(
-        Plane3d {
-            half_size: Vec2::splat(size / 2.0),
-            ..default()
-        }
-    );
+    let mesh = meshes.add(Plane3d {
+        half_size: Vec2::splat(size / 2.0),
+        ..default()
+    });
 
     commands.spawn((
         PbrBundle {
@@ -285,18 +279,21 @@ pub fn ground(
             ..default()
         },
         Collider::halfspace(Vec3::Y).unwrap(),
-        ColliderDebugColor(Srgba {
-            red: 0.0,
-            green: 0.0,
-            blue: 0.0,
-            alpha: 0.0,
-        }.into()),
+        ColliderDebugColor(
+            Srgba {
+                red: 0.0,
+                green: 0.0,
+                blue: 0.0,
+                alpha: 0.0,
+            }
+            .into(),
+        ),
         //Collider::cuboid(size / 2.0, 0.1, size / 2.0),
         Name::from("Ground"),
     ));
 
     let material = mats.add(Color::from(css::WHITE));
-    let mesh = meshes.add( Sphere::new(0.5));
+    let mesh = meshes.add(Sphere::new(0.5));
     commands.spawn((
         PbrBundle {
             mesh,
@@ -345,7 +342,9 @@ pub fn stairs(
         ..default()
     });
 
-    let mesh = meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5) }));
+    let mesh = meshes.add(Mesh::from(Cuboid {
+        half_size: Vec3::splat(0.5),
+    }));
     steps(
         Transform {
             translation: Vec3::new(5.0, 0.0, -5.0),
@@ -451,7 +450,9 @@ pub fn walls(
         commands
             .spawn((
                 PbrBundle {
-                    mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
+                    mesh: meshes.add(Mesh::from(Cuboid {
+                        half_size: Vec3::splat(0.5),
+                    })),
                     material: material,
                     transform: Transform {
                         translation: Vec3::new(0.0, 0.0, part as f32 * width),
@@ -469,7 +470,9 @@ pub fn walls(
     commands
         .spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
+                mesh: meshes.add(Mesh::from(Cuboid {
+                    half_size: Vec3::splat(0.5),
+                })),
                 material: materials[0].clone(),
                 transform: Transform {
                     translation: Vec3::new(0.0, 0.0, ((parts + 1) as f32 * width) * 1.5),
@@ -506,7 +509,9 @@ pub fn slopes(
         let rotation_diff = width * radians;
         commands.spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
+                mesh: meshes.add(Mesh::from(Cuboid {
+                    half_size: Vec3::splat(0.5),
+                })),
                 material: material.clone(),
                 transform: Transform {
                     translation: Vec3::new(rotation_diff, 0.0, angle as f32 * width + width * 2.0),
@@ -521,7 +526,9 @@ pub fn slopes(
 
         commands.spawn((
             PbrBundle {
-                mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
+                mesh: meshes.add(Mesh::from(Cuboid {
+                    half_size: Vec3::splat(0.5),
+                })),
                 material: material.clone(),
                 transform: Transform {
                     translation: Vec3::new(
@@ -557,7 +564,9 @@ pub fn moving_objects(
     let simple_width = 3.0;
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5), })),
+            mesh: meshes.add(Mesh::from(Cuboid {
+                half_size: Vec3::splat(0.5),
+            })),
             material: material.clone(),
             transform: Transform {
                 translation: Vec3::new(-5.0, 0.3, 10.0),
@@ -604,7 +613,9 @@ pub fn moving_objects(
     let simple_width = 3.0;
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(Cuboid { half_size: Vec3::splat(0.5) })),
+            mesh: meshes.add(Mesh::from(Cuboid {
+                half_size: Vec3::splat(0.5),
+            })),
             material: material.clone(),
             transform: Transform {
                 translation: Vec3::new(-5.0, 0.3, 10.0),
diff --git a/examples/starship.rs b/examples/starship.rs
index bf86efc..ff08f37 100644
--- a/examples/starship.rs
+++ b/examples/starship.rs
@@ -1,10 +1,10 @@
 use std::f32::consts::FRAC_PI_2;
 
 use bevy::{
+    color::palettes::css,
     input::mouse::MouseMotion,
     prelude::*,
     window::{Cursor, CursorGrabMode, PrimaryWindow},
-    color::palettes::css,
 };
 use bevy_mod_wanderlust::{
     ControllerBundle, ControllerInput, ControllerPhysicsBundle, WanderlustPlugin,
@@ -53,7 +53,12 @@ fn setup(
     ass: Res<AssetServer>,
 ) {
     // Origin cube to be able to tell how you're moving
-    let mesh = meshes.add(Cuboid { half_size: Vec3::splat(5.0) }.into());
+    let mesh = meshes.add(
+        Cuboid {
+            half_size: Vec3::splat(5.0),
+        }
+        .into(),
+    );
     let material = mats.add(Color::from(css::WHITE));
 
     c.spawn(PbrBundle {
diff --git a/src/plugins.rs b/src/plugins.rs
index 8ccb435..3d61572 100644
--- a/src/plugins.rs
+++ b/src/plugins.rs
@@ -1,5 +1,9 @@
 use crate::controller::*;
-use bevy::{ecs::{intern::Interned, schedule::ScheduleLabel}, prelude::*, utils::HashSet};
+use bevy::{
+    ecs::{intern::Interned, schedule::ScheduleLabel},
+    prelude::*,
+    utils::HashSet,
+};
 use bevy_rapier3d::prelude::*;
 
 /// The [character controller](CharacterController) plugin. Necessary to have the character controller