Bevy 0.12 upgrade (#8)

* refactor for bevy 0.12

* minory clippy

* wrap both asset id cases

* only deal with uuid assets, skip the rest

* circumnvent a cargo bug

* fix bug

* fix docs

* update docs

* main bevy

* using updated renet

* using fixed branch

* using temp renet

* fixing new method

* convert other methods

* unit test serde for material

* avoid cloning

* fix last test

* use uuids only

* fix

* logging reworked

* also test meshes

* use added

* bevy upgrade

* point to main

* remove moved methods

* complex allowed

Cargo.toml

@@ -16,12 +16,13 @@ include = ["/src", "/LICENSE-MIT", "/LICENSE-APACHE"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.11.0" }
-bevy_renet = "0.0.9"
+bevy = { version = "0.12" }
+bevy_renet = { git = "https://github.com/lucaspoffo/renet.git" }
 bincode = "1.3.3"
 serde = { version = "1.0.160", features = ["derive"] }
 
 [dev-dependencies]
 portpicker = "0.1.1"
 serial_test = "2.0.0"
-bevy_editor_pls = { git = "https://github.com/jakobhellermann/bevy_editor_pls.git", branch = "main" }
+bevy_editor_pls = { git = "https://github.com/jakobhellermann/bevy_editor_pls" }
+uuid = "1.5.0"

README.md

@@ -16,6 +16,8 @@ Current state is in development.
 - [ ] Asset: Textures
 - [ ] Asset: Audio
 
+**Asset are synchronized only if they are added to bevy by uuid.**
+
 ## Examples
 
 Run both examples so the they connect to each other:

examples/host.rs

@@ -3,12 +3,9 @@ use std::{
  net::{IpAddr, Ipv4Addr},
 };
 
-use bevy::{
- pbr::wireframe::{Wireframe, WireframeConfig},
- prelude::*,
- render::primitives::Aabb,
-};
+use bevy::{prelude::*, render::primitives::Aabb};
 use bevy_sync::{ServerPlugin, SyncComponent, SyncExclude, SyncMark, SyncPlugin};
+use uuid::Uuid;
 
 fn main() {
  if env::var("RUST_LOG").is_err() {
@@ -27,7 +24,6 @@ fn main() {
  host.sync_component::<Aabb>();
  host.sync_component::<Visibility>();
  host.sync_component::<Transform>();
- host.sync_component::<Wireframe>();
  host.sync_component::<PointLight>();
  host.sync_component::<Handle<StandardMaterial>>();
  host.sync_component::<Handle<Mesh>>();
@@ -38,17 +34,28 @@ fn main() {
  host.run();
 }
 
+trait AddByUuid<A: Asset> {
+ fn addu(&mut self, asset: A) -> Handle<A>;
+}
+impl<A: Asset> AddByUuid<A> for Assets<A> {
+ fn addu(&mut self, asset: A) -> Handle<A> {
+ let id = AssetId::Uuid {
+ uuid: Uuid::new_v4(),
+ };
+ self.insert(id, asset);
+ Handle::<A>::Weak(id)
+ }
+}
+
 fn load_world(
  mut commands: Commands,
- mut wireframe_config: ResMut<WireframeConfig>,
  mut meshes: ResMut<Assets<Mesh>>,
  mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
- wireframe_config.global = false;
  commands.spawn((
  PbrBundle {
- mesh: meshes.add(shape::Plane::from_size(5.0).into()),
- material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
+ mesh: meshes.addu(shape::Plane::from_size(5.0).into()),
+ material: materials.addu(Color::rgb(0.3, 0.5, 0.3).into()),
  ..default()
  },
  SyncMark,
@@ -57,12 +64,11 @@ fn load_world(
  ));
  commands.spawn((
  PbrBundle {
- mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
- material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+ mesh: meshes.addu(Mesh::from(shape::Cube { size: 1.0 })),
+ material: materials.addu(Color::rgb(0.8, 0.7, 0.6).into()),
  transform: Transform::from_xyz(0.0, 0.5, 0.0),
  ..default()
  },
- Wireframe,
  SyncMark,
  Name::new("Cube"),
  ));

src/bundle_fix.rs

@@ -20,16 +20,17 @@ impl Plugin for BundleFixPlugin {
 
 fn fix_computed_visibility(
  mut cmd: Commands,
- query: Query<Entity, (With<Visibility>, Without<ComputedVisibility>)>,
+ query: Query<Entity, (Added<Visibility>, Without<ViewVisibility>)>,
 ) {
  for e in query.iter() {
- cmd.entity(e).insert(ComputedVisibility::default());
+ cmd.entity(e).insert(ViewVisibility::default());
  }
 }
 
+#[allow(clippy::type_complexity)]
 fn fix_missing_global_transforms(
  mut cmd: Commands,
- query: Query<(Entity, &Transform), Without<GlobalTransform>>,
+ query: Query<(Entity, &Transform), (Added<Transform>, Without<GlobalTransform>)>,
 ) {
  for (e, &t) in query.iter() {
  cmd.entity(e).insert(GlobalTransform::from(t));
@@ -38,7 +39,7 @@ fn fix_missing_global_transforms(
 
 fn fix_missing_cubemap_frusta(
  mut cmd: Commands,
- query: Query<Entity, (With<PointLight>, Without<CubemapFrusta>)>,
+ query: Query<Entity, (Added<PointLight>, Without<CubemapFrusta>)>,
 ) {
  for e in query.iter() {
  cmd.entity(e).insert(CubemapFrusta::default());
@@ -47,7 +48,7 @@ fn fix_missing_cubemap_frusta(
 
 fn fix_missing_cubemap_visible_entities(
  mut cmd: Commands,
- query: Query<Entity, (With<PointLight>, Without<CubemapVisibleEntities>)>,
+ query: Query<Entity, (Added<PointLight>, Without<CubemapVisibleEntities>)>,
 ) {
  for e in query.iter() {
  cmd.entity(e).insert(CubemapVisibleEntities::default());

src/client/mod.rs

@@ -27,13 +27,11 @@ impl Plugin for ClientSyncPlugin {
  Update,
  client_connected
  .run_if(state_exists_and_equals(ClientState::Connecting))
- .run_if(bevy_renet::transport::client_connected()),
  );
  app.add_systems(
  Update,
  client_connecting
  .run_if(state_exists_and_equals(ClientState::Disconnected))
- .run_if(bevy_renet::transport::client_connecting()),
  );
  app.add_systems(
  Update,

src/client/receiver.rs

@@ -1,3 +1,5 @@
+use crate::logging::{log_message_received, Who};
+
 use super::*;
 
 pub(crate) fn poll_for_messages(
@@ -22,13 +24,9 @@ fn receive_as_client(
 }
 
 fn client_received_a_message(msg: Message, track: &mut ResMut<SyncTrackerRes>, cmd: &mut Commands) {
+ log_message_received(Who::Client, &msg);
  match msg {
  Message::EntitySpawn { id } => {
- debug!(
- "Client received of type EntitySpawn for server entity {}v{}",
- id.index(),
- id.generation()
- );
  if let Some(e_id) = track.server_to_client_entities.get(&id) {
  if cmd.get_entity(*e_id).is_some() {
  return;
@@ -46,11 +44,6 @@ fn client_received_a_message(msg: Message, track: &mut ResMut<SyncTrackerRes>, c
  server_entity_id: id,
  client_entity_id: back_id,
  } => {
- debug!(
- "Client received of type EntitySpawnBack for server entity {}v{}",
- id.index(),
- id.generation()
- );
  if let Some(mut e) = cmd.get_entity(back_id) {
  e.remove::<SyncMark>().insert(SyncUp {
  server_entity_id: id,
@@ -61,31 +54,35 @@ fn client_received_a_message(msg: Message, track: &mut ResMut<SyncTrackerRes>, c
  server_entity_id: e_id,
  server_parent_id: p_id,
  } => {
- let Some(&c_e_id) = track.server_to_client_entities.get(&e_id) else {return};
- let Some(&c_p_id) = track.server_to_client_entities.get(&p_id) else {return};
+ let Some(&c_e_id) = track.server_to_client_entities.get(&e_id) else {
+ return;
+ };
+ let Some(&c_p_id) = track.server_to_client_entities.get(&p_id) else {
+ return;
+ };
  cmd.add(move |world: &mut World| {
  let mut entity = world.entity_mut(c_e_id);
  let opt_parent = entity.get::<Parent>();
  if opt_parent.is_none() || opt_parent.unwrap().get() != c_p_id {
- entity.set_parent(p_id);
+ entity.set_parent(c_p_id);
  world.entity_mut(c_p_id).add_child(c_e_id);
  }
  });
  }
  Message::EntityDelete { id } => {
- debug!(
- "Client received of type EntityDelete for server entity {}v{}",
- id.index(),
- id.generation()
- );
- let Some(&e_id) = track.server_to_client_entities.get(&id) else {return};
- let Some(mut e) = cmd.get_entity(e_id) else {return};
+ let Some(&e_id) = track.server_to_client_entities.get(&id) else {
+ return;
+ };
+ let Some(mut e) = cmd.get_entity(e_id) else {
+ return;
+ };
  e.despawn();
  }
  Message::ComponentUpdated { id, name, data } => {
- let Some(&e_id) = track.server_to_client_entities.get(&id) else {return};
- let mut entity = cmd.entity(e_id);
- entity.add(move |_: Entity, world: &mut World| {
+ let Some(&e_id) = track.server_to_client_entities.get(&id) else {
+ return;
+ };
+ cmd.add(move |world: &mut World| {
  SyncTrackerRes::apply_component_change_from_network(e_id, name, &data, world);
  });
  }

src/client/track.rs

@@ -35,7 +35,9 @@ pub(crate) fn entity_parented_on_client(
  query_parent: Query<(Entity, &SyncUp), With<Children>>,
 ) {
  for (p, sup) in query.iter() {
- let Ok(parent) = query_parent.get_component::<SyncUp>(p.get()) else {return};
+ let Ok(parent) = query_parent.get_component::<SyncUp>(p.get()) else {
+ return;
+ };
  client.send_message(
  DefaultChannel::ReliableOrdered,
  bincode::serialize(&Message::EntityParented {
@@ -77,17 +79,13 @@ pub(crate) fn react_on_changed_components(
  mut track: ResMut<SyncTrackerRes>,
 ) {
  let registry = registry.read();
- while let Some(change) = track.changed_components.pop_front() {
- debug!(
- "Component was changed on client: {}",
- change.data.type_name()
- );
- client.send_message(
+ while let Some(change) = track.changed_components_to_send.pop_front() {
+ client.send_message(
  DefaultChannel::ReliableOrdered,
  bincode::serialize(&Message::ComponentUpdated {
  id: change.change_id.id,
  name: change.change_id.name,
- data: compo_to_bin(change.data.clone_value(), &registry),
+ data: compo_to_bin(change.data.as_reflect(), &registry),
  })
  .unwrap(),
  );
@@ -102,23 +100,29 @@ pub(crate) fn react_on_changed_materials(
  mut events: EventReader<AssetEvent<StandardMaterial>>,
 ) {
  let registry = registry.read();
- for event in &mut events {
+ for event in &mut events.read() {
  match event {
- AssetEvent::Created { handle } | AssetEvent::Modified { handle } => {
- let Some(material) = materials.get(handle) else { return; };
- if track.skip_network_handle_change(handle.id()) {
+ AssetEvent::Added { id } | AssetEvent::Modified { id } => {
+ let Some(material) = materials.get(*id) else {
+ return;
+ };
+ let AssetId::Uuid { uuid: id } = id else {
+ return;
+ };
+ if track.skip_network_handle_change(*id) {
  return;
  }
  client.send_message(
  DefaultChannel::ReliableOrdered,
  bincode::serialize(&Message::StandardMaterialUpdated {
- id: handle.id(),
- material: compo_to_bin(material.clone_value(), &registry),
+ id: *id,
+ material: compo_to_bin(material.as_reflect(), &registry),
  })
  .unwrap(),
  );
  }
- AssetEvent::Removed { handle: _ } => {}
+ AssetEvent::Removed { id: _ } => {}
+ _ => (),
  }
  }
 }
@@ -129,23 +133,29 @@ pub(crate) fn react_on_changed_meshes(
  assets: Res<Assets<Mesh>>,
  mut events: EventReader<AssetEvent<Mesh>>,
 ) {
- for event in &mut events {
+ for event in &mut events.read() {
  match event {
- AssetEvent::Created { handle } | AssetEvent::Modified { handle } => {
- let Some(mesh) = assets.get(handle) else { return; };
- if track.skip_network_handle_change(handle.id()) {
+ AssetEvent::Added { id } | AssetEvent::Modified { id } => {
+ let Some(mesh) = assets.get(*id) else {
+ return;
+ };
+ let AssetId::Uuid { uuid: id } = id else {
+ return;
+ };
+ if track.skip_network_handle_change(*id) {
  return;
  }
  client.send_message(
  DefaultChannel::ReliableOrdered,
  bincode::serialize(&Message::MeshUpdated {
- id: handle.id(),
+ id: *id,
  mesh: mesh_to_bin(mesh),
  })
  .unwrap(),
  );
  }
- AssetEvent::Removed { handle: _ } => {}
+ AssetEvent::Removed { id: _ } => {}
+ _ => (),
  }
  }
 }

src/lib.rs

@@ -24,11 +24,11 @@ let mut app = App::new();
 app.add_plugins(MinimalPlugins);
 
 // Either one of these two, if being server or client
-app.add_plugin(ServerPlugin { ip: Ipv4Addr::LOCALHOST.into(), port: 5555 });
+app.add_plugins(ServerPlugin { ip: Ipv4Addr::LOCALHOST.into(), port: 5555 });
 //app.add_plugin(ClientPlugin { ip: Ipv4Addr::LOCALHOST.into(), port: 5555 });
 
 // Setup sync mechanics and which components will be synced
-app.add_plugin(SyncPlugin);
+app.add_plugins(SyncPlugin);
 app.sync_component::<Transform>();
 
 // Mark entity for sync with SyncMark component
@@ -45,6 +45,7 @@ mod networking;
 mod proto;
 mod proto_serde;
 mod server;
+mod logging;
 
 pub mod prelude {
  pub use super::{
@@ -106,7 +107,9 @@ pub struct SyncUp {
 }
 
 pub trait SyncComponent {
- fn sync_component<T: Component + Reflect + FromReflect + GetTypeRegistration>(
+ fn sync_component<
+ T: Component + TypePath + DynamicTypePath + Reflect + FromReflect + GetTypeRegistration,
+ >(
  &mut self,
  ) -> &mut Self;
  fn sync_materials(&mut self, enable: bool);