Bevy 0.15 (#70)

Co-authored-by: IceSentry <[email protected]>

Author: Bendzae

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "bevy_polyline"
-version = "0.10.0"
+version = "0.11.0"
 description = "Polyline Rendering for Bevy"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/ForesightMiningSoftwareCorporation/bevy_polyline"
@@ -18,7 +18,7 @@ authors = [
 
 [dependencies]
 bitflags = "2.3"
-bevy = { version = "0.14", default-features = false, features = [
+bevy = { version = "0.15", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
@@ -29,7 +29,8 @@ bytemuck = "1.16.1"
 lazy_static = "1.4.0"
 rand = "0.8.4"
 ringbuffer = "0.15"
-bevy = { version = "0.14", default-features = false, features = [
+bevy = { version = "0.15", default-features = false, features = [
+    "bevy_window",
     "bevy_winit",
     "bevy_pbr",
     "x11",

examples/depth_bias.rs

@@ -22,7 +22,6 @@ use bevy_polyline::prelude::*;
 fn main() {
     App::new()
         .insert_resource(ClearColor(Color::BLACK))
-        .insert_resource(Msaa::Sample4)
         .add_plugins(DefaultPlugins)
         .add_plugins(PolylinePlugin)
         .add_systems(Update, (move_camera, rotate_plane))
@@ -34,7 +33,7 @@ fn main() {
 struct Rotating(f64);
 
 fn rotate_plane(time: Res<Time>, mut animated: Query<(&mut Transform, &Rotating)>) {
-    let time = time.elapsed_seconds_f64();
+    let time = time.elapsed_secs_f64();
     for (mut trans, Rotating(period)) in animated.iter_mut() {
         let angle = time % period / period * TAU64;
         let rot = Quat::from_rotation_y(angle as f32);
@@ -61,30 +60,29 @@ fn setup(
     mut polylines: ResMut<Assets<Polyline>>,
     mut materials: ResMut<Assets<PolylineMaterial>>,
 ) {
-    commands
-        .spawn(Camera3dBundle::default())
-        .insert(Transform::from_xyz(100.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y));
     commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Cuboid::from_size(Vec3::new(0.01, 100.0, 10000.0)).mesh()),
-            material: pbr_materials.add(Color::WHITE),
-            ..default()
-        },
+        Camera3d::default(),
+        Msaa::Sample4,
+        Transform::from_xyz(100.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::from_size(Vec3::new(0.01, 100.0, 10000.0)).mesh())),
+        MeshMaterial3d(pbr_materials.add(Color::WHITE)),
         Rotating(30.0),
     ));
     let top = Vec3::Y * 100.0;
     let bottom = Vec3::Y * -100.0;
     // Show the middle as a vertical red bar.
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
+        polyline: PolylineHandle(polylines.add(Polyline {
             vertices: vec![top, bottom],
-        }),
-        material: materials.add(PolylineMaterial {
+        })),
+        material: PolylineMaterialHandle(materials.add(PolylineMaterial {
             width: 5.0,
             color: RED.into(),
             depth_bias: -1.0,
             perspective: false,
-        }),
+        })),
         ..Default::default()
     });
     // Draw from bottom to top, red to purple, -1.0 to 1.0 horizontal lines
@@ -93,15 +91,15 @@ fn setup(
         let left = Vec3::new(0.0, bias * 35.0, -500.0);
         let right = Vec3::new(0.0, bias * 35.0, 500.0);
         commands.spawn(PolylineBundle {
-            polyline: polylines.add(Polyline {
+            polyline: PolylineHandle(polylines.add(Polyline {
                 vertices: vec![left, right],
-            }),
-            material: materials.add(PolylineMaterial {
+            })),
+            material: PolylineMaterialHandle(materials.add(PolylineMaterial {
                 width: 1.0,
                 color: Color::hsl((bias + 1.0) / 2.0 * 270.0, 1.0, 0.5).to_linear(),
                 depth_bias: bias,
                 perspective: false,
-            }),
+            })),
             ..Default::default()
         });
     }

examples/linestrip.rs

@@ -1,9 +1,8 @@
-use bevy::{color::palettes::css::RED, pbr::PointLightBundle, prelude::*};
+use bevy::{color::palettes::css::RED, prelude::*};
 use bevy_polyline::prelude::*;
 
 fn main() {
     App::new()
-        .insert_resource(Msaa::Sample4)
         .add_plugins(DefaultPlugins)
         .add_plugins(PolylinePlugin)
         .add_systems(Startup, setup)
@@ -19,7 +18,7 @@ fn setup(
     mut polylines: ResMut<Assets<Polyline>>,
 ) {
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
+        polyline: PolylineHandle(polylines.add(Polyline {
             vertices: vec![
                 Vec3::new(-0.5, -0.5, -0.5),
                 Vec3::new(0.5, -0.5, -0.5),
@@ -30,45 +29,39 @@ fn setup(
                 Vec3::new(0.5, -0.5, 0.5),
                 Vec3::new(-0.5, -0.5, 0.5),
             ],
-        }),
-        material: polyline_materials.add(PolylineMaterial {
+        })),
+        material: PolylineMaterialHandle(polyline_materials.add(PolylineMaterial {
             width: 2.0,
             color: RED.into(),
             perspective: false,
             // Bias the line toward the camera so the line at the cube-plane intersection is visible
             depth_bias: -0.0002,
-        }),
+        })),
         ..Default::default()
     });
 
     // circular base
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Circle::new(4.0)),
-        material: standard_materials.add(Color::WHITE),
-        transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2))
+    commands.spawn((
+        Mesh3d(meshes.add(Circle::new(4.0))),
+        MeshMaterial3d(standard_materials.add(Color::WHITE)),
+        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2))
             .with_translation(Vec3::new(0.0, -0.5, 0.0)),
-        ..default()
-    });
+    ));
     // cube
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Cuboid::from_size(Vec3::ONE)),
-        material: standard_materials.add(Color::srgb_u8(124, 144, 255)),
-        transform: Transform::from_xyz(0.0, 0.0, 0.0),
-        ..default()
-    });
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::from_size(Vec3::ONE))),
+        MeshMaterial3d(standard_materials.add(Color::srgb_u8(124, 144, 255))),
+        Transform::from_xyz(0.0, 0.0, 0.0),
+    ));
 
     // light
-    commands.spawn(PointLightBundle {
-        transform: Transform::from_xyz(4.0, 8.0, 4.0),
-        ..Default::default()
-    });
+    commands.spawn((PointLight::default(), Transform::from_xyz(4.0, 8.0, 4.0)));
 
     // camera
     commands.spawn((
-        Camera3dBundle {
-            transform: Transform::from_xyz(-2.0, 2.5, -5.0).looking_at(Vec3::ZERO, Vec3::Y),
-            ..Camera3dBundle::default()
-        },
+        Camera3d::default(),
+        Msaa::Sample4,
+        Transform::from_xyz(-2.0, 2.5, -5.0).looking_at(Vec3::ZERO, Vec3::Y),
         Rotates,
     ));
 }
@@ -80,7 +73,7 @@ struct Rotates;
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
     for mut transform in query.iter_mut() {
         *transform = Transform::from_rotation(Quat::from_rotation_y(
-            (4.0 * std::f32::consts::PI / 20.0) * time.delta_seconds(),
+            (4.0 * std::f32::consts::PI / 20.0) * time.delta_secs(),
         )) * *transform;
     }
 }

examples/minimal.rs

@@ -15,25 +15,26 @@ fn setup(
     mut polylines: ResMut<Assets<Polyline>>,
 ) {
     commands.spawn(PolylineBundle {
-        polyline: polylines.add(Polyline {
+        polyline: PolylineHandle(polylines.add(Polyline {
             vertices: vec![-Vec3::ONE, Vec3::ONE],
-        }),
-        material: polyline_materials.add(PolylineMaterial {
+        })),
+        material: PolylineMaterialHandle(polyline_materials.add(PolylineMaterial {
             width: 10.0,
             color: RED.into(),
             perspective: false,
             ..default()
-        }),
+        })),
         ..default()
     });
 
     // camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(0.0, 0.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        camera: Camera {
+    commands.spawn((
+        Camera3d::default(),
+        Camera {
             hdr: true,
             ..default()
         },
-        ..default()
-    });
+        Msaa::Sample4,
+        Transform::from_xyz(0.0, 0.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
 }

examples/nbody.rs

@@ -1,6 +1,7 @@
 use std::f32::consts::PI;
 
 use bevy::{
+    core_pipeline::{bloom::Bloom, tonemapping::Tonemapping},
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     math::Vec3A,
     prelude::*,
@@ -18,7 +19,6 @@ const MINIMUM_ANGLE: f32 = 1.483_418_7; // == acos(5 degrees)
 fn main() {
     App::new()
         .insert_resource(ClearColor(Color::BLACK))
-        .insert_resource(Msaa::Sample4)
         .insert_resource(Simulation {
             scale: 1e6,
             ..Default::default()
@@ -59,32 +59,33 @@ fn setup(
             },
             Trail(ConstGenericRingBuffer::<Vec3A, TRAIL_LENGTH>::new()),
             PolylineBundle {
-                polyline: polylines.add(Polyline {
+                polyline: PolylineHandle(polylines.add(Polyline {
                     vertices: Vec::with_capacity(TRAIL_LENGTH),
-                }),
-                material: polyline_materials.add(PolylineMaterial {
-                    width: (size * 0.1).powf(1.8),
-                    color: Color::hsl(rng.gen_range(0.0..360.0), 1.0, rng.gen_range(1.2..3.0))
-                        .to_linear(),
-                    perspective: true,
-                    ..Default::default()
-                }),
+                })),
+                material: PolylineMaterialHandle(
+                    polyline_materials.add(PolylineMaterial {
+                        width: (size * 0.1).powf(1.8),
+                        color: Color::hsl(rng.gen_range(0.0..360.0), 1.0, rng.gen_range(1.2..3.0))
+                            .to_linear(),
+                        perspective: true,
+                        ..Default::default()
+                    }),
+                ),
                 ..Default::default()
             },
         ));
     }
 
     // camera
     commands.spawn((
-        Camera3dBundle {
-            camera: Camera {
-                hdr: true,
-                ..default()
-            },
-            tonemapping: bevy::core_pipeline::tonemapping::Tonemapping::TonyMcMapface,
+        Camera3d::default(),
+        Camera {
+            hdr: true,
             ..default()
         },
-        bevy::core_pipeline::bloom::BloomSettings { ..default() },
+        Msaa::Sample4,
+        Tonemapping::TonyMcMapface,
+        Bloom::default(),
         Rotates,
     ));
 }
@@ -95,7 +96,7 @@ struct Rotates;
 
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
     for mut transform in query.iter_mut() {
-        let t = time.elapsed_seconds();
+        let t = time.elapsed_secs();
         let r = 1100.0;
         *transform = Transform::from_xyz(
             r * f32::cos(t * 0.1),
@@ -136,7 +137,7 @@ impl Default for Simulation {
 impl Simulation {
     fn update(&mut self, time: &Time) {
         if !self.is_paused {
-            self.accumulator += time.delta_seconds();
+            self.accumulator += time.delta_secs();
         }
     }
 
@@ -157,7 +158,7 @@ const EPSILON: f32 = 1.;
 fn nbody_system(
     time: Res<Time>,
     mut simulation: ResMut<Simulation>,
-    mut query: Query<(Entity, &mut Body, &mut Trail, &Handle<Polyline>)>,
+    mut query: Query<(Entity, &mut Body, &mut Trail, &PolylineHandle)>,
 ) {
     let mut bodies = query.iter_mut().collect::<Vec<_>>();
     // dbg!(&bodies);
@@ -204,7 +205,7 @@ fn nbody_system(
 
 fn update_trails(
     mut polylines: ResMut<Assets<Polyline>>,
-    mut query: Query<(&Body, &mut Trail, &Handle<Polyline>)>,
+    mut query: Query<(&Body, &mut Trail, &PolylineHandle)>,
 ) {
     query.iter_mut().for_each(|(body, mut trail, polyline)| {
         if let Some(position) = trail.0.back() {
@@ -217,14 +218,14 @@ fn update_trails(
             let gt_min_angle = last_vec.dot(last_last_vec) > MINIMUM_ANGLE;
             if gt_min_angle {
                 trail.0.push(body.position);
-                polylines.get_mut(polyline).unwrap().vertices =
+                polylines.get_mut(&polyline.0).unwrap().vertices =
                     trail.0.iter().map(|v| Vec3::from(*v)).collect()
             } else {
                 // If the last point didn't actually add much of a curve, just overwrite it.
-                if polylines.get_mut(polyline).unwrap().vertices.len() > 1 {
+                if polylines.get_mut(&polyline.0).unwrap().vertices.len() > 1 {
                     *trail.0.get_mut_signed(-1).unwrap() = body.position;
                     *polylines
-                        .get_mut(polyline)
+                        .get_mut(&polyline.0)
                         .unwrap()
                         .vertices
                         .last_mut()
@@ -233,7 +234,7 @@ fn update_trails(
             }
         } else {
             trail.0.push(body.position);
-            polylines.get_mut(polyline).unwrap().vertices =
+            polylines.get_mut(&polyline.0).unwrap().vertices =
                 trail.0.iter().map(|v| Vec3::from(*v)).collect()
         }
     });