Update bevy, hecs, legion, specs and shipyard

Cargo.toml

@@ -7,18 +7,18 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy_ecs = "0.5.0"
-bevy_tasks = "0.5.0"
+bevy_ecs = "0.8.0"
+bevy_tasks = "0.8.0"
 bincode = "1.3"
-cgmath = { version = "0.17", features = ["serde"] }
-hecs = { version = "0.5", features = ["column-serialize", "row-serialize"] }
-legion = "0.3"
+cgmath = { version = "0.18", features = ["serde"] }
+hecs = { version = "0.7", features = ["column-serialize", "row-serialize"] }
+legion = "0.4"
 planck_ecs = { version = "1.1.0", features = ["parallel"] }
 rayon = "1.3"
-ron = "0.6"
+ron = "0.8"
 serde = { version = "1.0", features = ["derive"] }
-shipyard = "0.5.0"
-specs = {version = "0.16.1", features = ["serde"] }
+shipyard = "0.6.0"
+specs = {version = "0.18", features = ["serde"] }
 specs-derive = "0.4.1"
 
 [dev-dependencies]

src/bevy/add_remove.rs

@@ -1,6 +1,9 @@
 use bevy_ecs::prelude::*;
 
+#[derive(bevy_ecs::component::Component)]
 struct A(f32);
+
+#[derive(bevy_ecs::component::Component)]
 struct B(f32);
 
 pub struct Benchmark(World, Vec<Entity>);

src/bevy/frag_iter.rs

@@ -3,12 +3,15 @@ use bevy_ecs::prelude::*;
 macro_rules! create_entities {
     ($world:ident; $( $variants:ident ),*) => {
         $(
+            #[derive(bevy_ecs::component::Component)]
             struct $variants(f32);
+
             $world.spawn_batch((0..20).map(|_| ($variants(0.0), Data(1.0))));
         )*
     };
 }
 
+#[derive(bevy_ecs::component::Component)]
 struct Data(f32);
 
 pub struct Benchmark(World);

src/bevy/heavy_compute.rs

@@ -1,16 +1,18 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::TaskPool;
 use cgmath::*;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Position(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Rotation(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Velocity(Vector3<f32>);
 
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
+struct Affine(Matrix4<f32>);
+
 pub struct Benchmark(World);
 
 impl Benchmark {
@@ -19,7 +21,7 @@ impl Benchmark {
 
         world.spawn_batch((0..1000).map(|_| {
             (
-                Matrix4::<f32>::from_angle_x(Rad(1.2)),
+                Affine(Matrix4::<f32>::from_angle_x(Rad(1.2))),
                 Position(Vector3::unit_x()),
                 Rotation(Vector3::unit_x()),
                 Velocity(Vector3::unit_x()),
@@ -30,15 +32,14 @@ impl Benchmark {
     }
 
     pub fn run(&mut self) {
-        let task_pool = TaskPool::new();
-        let mut query = self.0.query::<(&mut Position, &mut Matrix4<f32>)>();
+        let mut query = self.0.query::<(&mut Position, &mut Affine)>();
 
-        query.par_for_each_mut(&mut self.0, &task_pool, 64, |(mut pos, mut mat)| {
+        query.par_for_each_mut(&mut self.0, 64, |(mut pos, mut aff)| {
             for _ in 0..100 {
-                *mat = mat.invert().unwrap();
+                aff.0 = aff.0.invert().unwrap();
             }
 
-            pos.0 = mat.transform_vector(pos.0);
+            pos.0 = aff.0.transform_vector(pos.0);
         });
     }
 }

src/bevy/schedule.rs

@@ -1,9 +1,18 @@
 use bevy_ecs::{prelude::*, schedule::Schedule};
 
+#[derive(bevy_ecs::component::Component)]
 struct A(f32);
+
+#[derive(bevy_ecs::component::Component)]
 struct B(f32);
+
+#[derive(bevy_ecs::component::Component)]
 struct C(f32);
+
+#[derive(bevy_ecs::component::Component)]
 struct D(f32);
+
+#[derive(bevy_ecs::component::Component)]
 struct E(f32);
 
 fn ab(mut query: Query<(&mut A, &mut B)>) {
@@ -40,9 +49,9 @@ impl Benchmark {
 
         let mut schedule = Schedule::default();
         schedule.add_stage("main", SystemStage::parallel());
-        schedule.add_system_to_stage("main", ab.system());
-        schedule.add_system_to_stage("main", cd.system());
-        schedule.add_system_to_stage("main", ce.system());
+        schedule.add_system_to_stage("main", ab);
+        schedule.add_system_to_stage("main", cd);
+        schedule.add_system_to_stage("main", ce);
 
         Self(world, schedule)
     }

src/bevy/simple_insert.rs

@@ -1,16 +1,16 @@
 use bevy_ecs::prelude::*;
 use cgmath::*;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Transform(Matrix4<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Position(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Rotation(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Velocity(Vector3<f32>);
 
 pub struct Benchmark;

src/bevy/simple_iter.rs

@@ -1,16 +1,16 @@
 use bevy_ecs::prelude::*;
 use cgmath::*;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Transform(Matrix4<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Position(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Rotation(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bevy_ecs::component::Component)]
 struct Velocity(Vector3<f32>);
 
 pub struct Benchmark(World);

src/hecs/frag_iter.rs

@@ -23,7 +23,7 @@ impl Benchmark {
     }
 
     pub fn run(&mut self) {
-        for (_, mut data) in self.0.query_mut::<&mut Data>() {
+        for (_, mut data) in self.0.query::<&mut Data>().iter() {
             data.0 *= 2.0;
         }
     }

src/hecs/mod.rs

@@ -3,5 +3,5 @@ pub mod frag_iter;
 pub mod heavy_compute;
 pub mod simple_insert;
 pub mod simple_iter;
-pub mod serialize_binary;
-pub mod serialize_text;
+// pub mod serialize_binary;
+// pub mod serialize_text;

src/hecs/simple_iter.rs

@@ -31,7 +31,7 @@ impl Benchmark {
     }
 
     pub fn run(&mut self) {
-        for (_, (velocity, position)) in self.0.query_mut::<(&Velocity, &mut Position)>() {
+        for (_, (velocity, position)) in self.0.query::<(&Velocity, &mut Position)>().iter() {
             position.0 += velocity.0;
         }
     }

src/legion/mod.rs

@@ -2,7 +2,7 @@ pub mod add_remove;
 pub mod frag_iter;
 pub mod heavy_compute;
 pub mod schedule;
-pub mod serialize_binary;
-pub mod serialize_text;
+// pub mod serialize_binary;
+// pub mod serialize_text;
 pub mod simple_insert;
 pub mod simple_iter;

src/legion/serialize_binary.rs

@@ -52,7 +52,10 @@ impl Benchmark {
 
     pub fn run(&mut self) {
         let Self(world, registry) = self;
-        let serializable = &world.as_serializable(any(), &*registry);
+
+        let mut canon = legion::serialize::Canon::default();
+
+        let serializable = &world.as_serializable(any(), &*registry, &mut canon);
 
         let encoded = bincode::serialize(serializable).unwrap();
 
@@ -65,7 +68,7 @@ impl Benchmark {
         );
 
         registry
-            .as_deserialize()
+            .as_deserialize(&mut canon)
             .deserialize(&mut deserializer)
             .unwrap();
     }

src/legion/serialize_text.rs

@@ -52,13 +52,15 @@ impl Benchmark {
 
     pub fn run(&mut self) {
         let Self(world, registry) = self;
-        let serializable = &world.as_serializable(any(), &*registry);
+        let mut canon = legion::serialize::Canon::default();
+
+        let serializable = &world.as_serializable(any(), &*registry, &mut canon);
 
         let serialized = ron::ser::to_string(serializable).unwrap();
 
         let mut deserializer = ron::de::Deserializer::from_str(&serialized).unwrap();
         registry
-            .as_deserialize()
+            .as_deserialize(&mut canon)
             .deserialize(&mut deserializer)
             .unwrap();
     }

src/shipyard/add_remove.rs

@@ -1,6 +1,9 @@
 use shipyard::*;
 
+#[derive(Component)]
 struct A(f32);
+
+#[derive(Component)]
 struct B(f32);
 
 pub struct Benchmark(World, Vec<EntityId>);
@@ -16,7 +19,7 @@ impl Benchmark {
                 entity_ids.push(entity);
             }
             entity_ids
-        }).unwrap();
+        });
 
         Self(world, entities)
     }
@@ -26,12 +29,12 @@ impl Benchmark {
             for entity in &self.1 {
                 entities.add_component(*entity, &mut b, B(0.0));
             }
-        }).unwrap();
+        });
 
         self.0.run(|mut b: ViewMut<B>| {
             for entity in &self.1 {
                 b.remove(*entity);
             }
-        }).unwrap();
+        });
     }
 }

src/shipyard/frag_iter.rs

@@ -3,6 +3,7 @@ use shipyard::*;
 macro_rules! create_entities {
     ($world:ident; $( $variants:ident ),*) => {
         $(
+            #[derive(Component)]
             struct $variants(f32);
             $world.run(
                 | mut entities: EntitiesViewMut,
@@ -14,11 +15,12 @@ macro_rules! create_entities {
                         ($variants(0.0), Data(1.0)),
                     );
                 }
-            }).unwrap();
+            });
         )*
     };
 }
 
+#[derive(Component)]
 struct Data(f32);
 
 pub struct Benchmark(World);
@@ -37,6 +39,6 @@ impl Benchmark {
             (&mut data).iter().for_each(|mut data| {
                 data.0 *= 2.0;
             })
-        }).unwrap();
+        });
     }
 }

src/shipyard/heavy_compute.rs

@@ -1,16 +1,19 @@
-use cgmath::*;
+use cgmath::{Transform as _, *};
 use rayon::prelude::*;
 use shipyard::*;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Component)]
 struct Position(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Component)]
 struct Rotation(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Component)]
 struct Velocity(Vector3<f32>);
 
+#[derive(Copy, Clone, Component)]
+struct Transform(Matrix4<f32>);
+
 pub struct Benchmark(World);
 
 impl Benchmark {
@@ -19,7 +22,7 @@ impl Benchmark {
 
         world.run(
             |mut entities: EntitiesViewMut,
-             mut transforms: ViewMut<Matrix4<f32>>,
+             mut transforms: ViewMut<Transform>,
              mut positions: ViewMut<Position>,
              mut rotations: ViewMut<Rotation>,
              mut velocities: ViewMut<Velocity>| {
@@ -32,31 +35,32 @@ impl Benchmark {
                             &mut velocities,
                         ),
                         (
-                            Matrix4::<f32>::from_angle_x(Rad(1.2)),
+                            Transform(Matrix4::<f32>::from_angle_x(Rad(1.2))),
                             Position(Vector3::unit_x()),
                             Rotation(Vector3::unit_x()),
                             Velocity(Vector3::unit_x()),
                         ),
                     );
                 }
             },
-        ).unwrap();
+        );
 
         Self(world)
     }
 
     pub fn run(&mut self) {
         self.0.run(
-            |mut positions: ViewMut<Position>, mut transforms: ViewMut<Matrix4<f32>>| {
-                (&mut positions, &mut transforms)
-                    .par_iter()
-                    .for_each(|(mut pos, mut mat)| {
+            |mut positions: ViewMut<Position>, mut transforms: ViewMut<Transform>| {
+                (&mut positions, &mut transforms).par_iter().for_each(
+                    |(mut pos, mut transform)| {
                         for _ in 0..100 {
-                            *mat = mat.invert().unwrap();
+                            transform.0 = transform.0.invert().unwrap();
                         }
-                        pos.0 = mat.transform_vector(pos.0);
-                    });
+
+                        pos.0 = transform.0.transform_vector(pos.0);
+                    },
+                );
             },
-        ).unwrap();
+        );
     }
 }