Updated renet to bevy 0.15

bevy_renet/Cargo.toml

@@ -20,15 +20,15 @@ name = "simple"
 required-features = ["netcode"]
 
 [dependencies]
-bevy_app = "0.14"
-bevy_ecs = "0.14"
-bevy_time = "0.14"
+bevy_app = "0.15.0"
+bevy_ecs = "0.15.0"
+bevy_time = "0.15.0"
 renet = { path="../renet", version = "0.0.16", features = ["bevy"] }
 renet_netcode = { path="../renet_netcode", version = "0.0.1", features = ["bevy"], optional = true }
 renet_steam = { path="../renet_steam", version = "0.0.2", features = ["bevy"], optional = true }
 
 [dev-dependencies]
-bevy = {version = "0.14", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
+bevy = {version = "0.15.0", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd", "bevy_window"]}
 bincode = "1.3"
 env_logger = "0.11"
 serde = {version = "1.0", features = ["derive"]}

bevy_renet/README.md

@@ -13,29 +13,31 @@ Bevy renet is a small layer over the `renet` crate, it adds systems to call the
 
 #### Server
 ```rust
-let mut app = App::new();
-app.add_plugin(RenetServerPlugin);
-
-let server = RenetServer::new(ConnectionConfig::default());
-app.insert_resource(server);
-
-// Transport layer setup
-app.add_plugin(NetcodeServerPlugin);
-let server_addr = "127.0.0.1:5000".parse().unwrap();
-let socket = UdpSocket::bind(server_addr).unwrap();
-let server_config = ServerConfig {
-    current_time: SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(),
-    max_clients: 64, 
-    protocol_id: 0,
-    public_addresses: vec![server_addr], 
-    authentication: ServerAuthentication::Unsecure
-};
-let transport = NetcodeServerTransport::new(server_config, socket).unwrap();
-app.insert_resource(transport);
-
-app.add_system(send_message_system);
-app.add_system(receive_message_system);
-app.add_system(handle_events_system);
+fn main() {
+    let mut app = App::new();
+    app.add_plugin(RenetServerPlugin);
+
+    let server = RenetServer::new(ConnectionConfig::default());
+    app.insert_resource(server);
+
+    // Transport layer setup
+    app.add_plugin(NetcodeServerPlugin);
+    let server_addr = "127.0.0.1:5000".parse().unwrap();
+    let socket = UdpSocket::bind(server_addr).unwrap();
+    let server_config = ServerConfig {
+        current_time: SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(),
+        max_clients: 64,
+        protocol_id: 0,
+        public_addresses: vec![server_addr],
+        authentication: ServerAuthentication::Unsecure
+    };
+    let transport = NetcodeServerTransport::new(server_config, socket).unwrap();
+    app.insert_resource(transport);
+
+    app.add_system(send_message_system);
+    app.add_system(receive_message_system);
+    app.add_system(handle_events_system);
+}
 
 // Systems
 
@@ -71,29 +73,31 @@ fn handle_events_system(mut server_events: EventReader<ServerEvent>) {
 
 #### Client
 ```rust
-let mut app = App::new();
-app.add_plugin(RenetClientPlugin);
-
-let client = RenetClient::new(ConnectionConfig::default());
-app.insert_resource(client);
-
-// Setup the transport layer
-app.add_plugin(NetcodeClientPlugin);
-
-let authentication = ClientAuthentication::Unsecure {
-    server_addr: SERVER_ADDR,
-    client_id: 0,
-    user_data: None,
-    protocol_id: 0,
-};
-let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
-let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
-let mut transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();
-
-app.insert_resource(transport);
-
-app.add_system(send_message_system);
-app.add_system(receive_message_system);
+fn main() {
+    let mut app = App::new();
+    app.add_plugin(RenetClientPlugin);
+
+    let client = RenetClient::new(ConnectionConfig::default());
+    app.insert_resource(client);
+
+    // Setup the transport layer
+    app.add_plugin(NetcodeClientPlugin);
+
+    let authentication = ClientAuthentication::Unsecure {
+        server_addr: SERVER_ADDR,
+        client_id: 0,
+        user_data: None,
+        protocol_id: 0,
+    };
+    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
+    let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+    let mut transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();
+
+    app.insert_resource(transport);
+
+    app.add_system(send_message_system);
+    app.add_system(receive_message_system);
+}
 
 // Systems
 
@@ -113,8 +117,8 @@ fn receive_message_system(mut client: ResMut<RenetClient>) {
 
 You can run the `simple` example with:
 
-* Server: `cargo run --features="serde transport" --example simple -- server`
-* Client: `cargo run --features="serde transport" --example simple -- client`
+* Server: `cargo run --features="netcode" --example simple -- server`
+* Client: `cargo run --features="netcode" --example simple -- client`
 
 If you want a more complex example you can checkout the [demo_bevy](https://github.com/lucaspoffo/renet/tree/master/demo_bevy) sample:
 

bevy_renet/examples/simple.rs

@@ -135,12 +135,11 @@ fn server_update_system(
                 println!("Player {} connected.", client_id);
                 // Spawn player cube
                 let player_entity = commands
-                    .spawn(PbrBundle {
-                        mesh: meshes.add(Cuboid::from_size(Vec3::splat(1.0))),
-                        material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
-                        transform: Transform::from_xyz(0.0, 0.5, 0.0),
-                        ..Default::default()
-                    })
+                    .spawn((
+                        Mesh3d(meshes.add(Cuboid::from_size(Vec3::splat(1.0)))),
+                        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+                        Transform::from_xyz(0.0, 0.5, 0.0),
+                    ))
                     .insert(PlayerInput::default())
                     .insert(Player { id: *client_id })
                     .id();
@@ -202,12 +201,11 @@ fn client_sync_players(
             ServerMessages::PlayerConnected { id } => {
                 println!("Player {} connected.", id);
                 let player_entity = commands
-                    .spawn(PbrBundle {
-                        mesh: meshes.add(Cuboid::from_size(Vec3::splat(1.0))),
-                        material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
-                        transform: Transform::from_xyz(0.0, 0.5, 0.0),
-                        ..Default::default()
-                    })
+                    .spawn((
+                        Mesh3d(meshes.add(Cuboid::from_size(Vec3::splat(1.0)))),
+                        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+                        Transform::from_xyz(0.0, 0.5, 0.0),
+                    ))
                     .id();
 
                 lobby.players.insert(id, player_entity);
@@ -238,25 +236,23 @@ fn client_sync_players(
 /// set up a simple 3D scene
 fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
     // plane
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(PlaneMeshBuilder::from_size(Vec2::splat(5.0)))),
-        material: materials.add(Color::srgb(0.3, 0.5, 0.3)),
-        ..Default::default()
-    });
+    commands.spawn((
+        Mesh3d(meshes.add(Mesh::from(PlaneMeshBuilder::from_size(Vec2::splat(5.0))))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+    ));
     // light
-    commands.spawn(PointLightBundle {
-        point_light: PointLight {
+    commands.spawn((
+        PointLight {
             shadows_enabled: true,
             ..default()
         },
-        transform: Transform::from_xyz(4.0, 8.0, 4.0),
-        ..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),
-        ..Default::default()
-    });
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
 }
 
 fn player_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut player_input: ResMut<PlayerInput>) {

demo_bevy/Cargo.toml

@@ -15,7 +15,7 @@ netcode = ["bevy_renet/netcode"]
 steam = ["bevy_renet/steam"]
 
 [dependencies]
-bevy = { version = "0.14", default-features = false, features = [
+bevy = { version = "0.15", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
@@ -25,12 +25,13 @@ bevy = { version = "0.14", default-features = false, features = [
     "ktx2",
     "zstd",
     "serialize",
+    "bevy_window"
 ]}
 
 bevy_renet = { path = "../bevy_renet", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 bincode = "1.3"
-bevy_egui = "0.28"
+bevy_egui = "0.31.1"
 renet_visualizer = { path = "../renet_visualizer", features = ["bevy"] }
 smooth-bevy-cameras = "0.12"
 fastrand = "2.0"

demo_bevy/README.md

@@ -6,8 +6,8 @@ Simple bevy application to demonstrates how you could replicate entities and sen
 
 Running using the netcode transport:
 
-- server: `cargo run --bin server --features transport`
-- client: `cargo run --bin client --features transport`
+- server: `cargo run --bin server --features netcode`
+- client: `cargo run --bin client --features netcode`
 
 Running using the steam transport:
 

demo_bevy/src/bin/client.rs

@@ -3,19 +3,16 @@ use std::collections::HashMap;
 use bevy::{
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     prelude::*,
-    window::PrimaryWindow,
+    prelude::Vec3
 };
+use bevy::window::PrimaryWindow;
 use bevy_egui::{EguiContexts, EguiPlugin};
-use bevy_renet::{
-    client_connected,
-    renet::{ClientId, RenetClient},
-    RenetClientPlugin,
-};
+use bevy_renet::{client_connected, renet::{ClientId, RenetClient}, RenetClientPlugin};
 use demo_bevy::{
     connection_config, setup_level, ClientChannel, NetworkedEntities, PlayerCommand, PlayerInput, ServerChannel, ServerMessages,
 };
 use renet_visualizer::{RenetClientVisualizer, RenetVisualizerStyle};
-use smooth_bevy_cameras::{LookTransform, LookTransformBundle, LookTransformPlugin, Smoother};
+// use smooth_bevy_cameras::{LookTransform, LookTransformBundle, LookTransformPlugin, Smoother};
 
 #[derive(Component)]
 struct ControlledPlayer;
@@ -125,7 +122,7 @@ fn main() {
     let mut app = App::new();
     app.add_plugins(DefaultPlugins);
     app.add_plugins(RenetClientPlugin);
-    app.add_plugins(LookTransformPlugin);
+    // app.add_plugins(LookTransformPlugin);
     app.add_plugins(FrameTimeDiagnosticsPlugin);
     app.add_plugins(LogDiagnosticsPlugin::default());
     app.add_plugins(EguiPlugin);
@@ -142,7 +139,7 @@ fn main() {
     app.insert_resource(PlayerInput::default());
     app.insert_resource(NetworkMapping::default());
 
-    app.add_systems(Update, (player_input, camera_follow, update_target_system));
+    app.add_systems(Update, (player_input, /*camera_follow,*/ update_target_system));
     app.add_systems(
         Update,
         (client_send_input, client_send_player_commands, client_sync_players).in_set(Connected),
@@ -220,12 +217,11 @@ fn client_sync_players(
         match server_message {
             ServerMessages::PlayerCreate { id, translation, entity } => {
                 println!("Player {} connected.", id);
-                let mut client_entity = commands.spawn(PbrBundle {
-                    mesh: meshes.add(Mesh::from(Capsule3d::default())),
-                    material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
-                    transform: Transform::from_xyz(translation[0], translation[1], translation[2]),
-                    ..Default::default()
-                });
+                let mut client_entity = commands.spawn((
+                    Mesh3d(meshes.add(Mesh::from(Capsule3d::default()))),
+                    MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+                    Transform::from_xyz(translation[0], translation[1], translation[2]),
+                ));
 
                 if client_id == id {
                     client_entity.insert(ControlledPlayer);
@@ -250,12 +246,11 @@ fn client_sync_players(
                 }
             }
             ServerMessages::SpawnProjectile { entity, translation } => {
-                let projectile_entity = commands.spawn(PbrBundle {
-                    mesh: meshes.add(Mesh::from(Sphere::new(0.1))),
-                    material: materials.add(Color::srgb(1.0, 0.0, 0.0)),
-                    transform: Transform::from_translation(translation.into()),
-                    ..Default::default()
-                });
+                let projectile_entity = commands.spawn((
+                    Mesh3d(meshes.add(Mesh::from(Sphere::new(0.1)))),
+                    MeshMaterial3d(materials.add(Color::srgb(1.0, 0.0, 0.0))),
+                    Transform::from_translation(translation.into()),
+                ));
                 network_mapping.0.insert(entity, projectile_entity.id());
             }
             ServerMessages::DespawnProjectile { entity } => {
@@ -293,7 +288,7 @@ fn update_target_system(
     let (camera, camera_transform) = camera_query.single();
     let mut target_transform = target_query.single_mut();
     if let Some(cursor_pos) = primary_window.single().cursor_position() {
-        if let Some(ray) = camera.viewport_to_world(camera_transform, cursor_pos) {
+        if let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_pos) {
             if let Some(distance) = ray.intersect_plane(Vec3::Y, InfinitePlane3d::new(Vec3::Y)) {
                 target_transform.translation = ray.direction * distance + ray.origin;
             }
@@ -303,32 +298,31 @@ fn update_target_system(
 
 fn setup_camera(mut commands: Commands) {
     commands
-        .spawn(LookTransformBundle {
+        .spawn(/*LookTransformBundle {
             transform: LookTransform {
                 eye: Vec3::new(0.0, 8., 2.5),
                 target: Vec3::new(0.0, 0.5, 0.0),
                 up: Vec3::Y,
             },
             smoother: Smoother::new(0.9),
         })
-        .insert(Camera3dBundle {
-            transform: Transform::from_xyz(0., 8.0, 2.5).looking_at(Vec3::new(0.0, 0.5, 0.0), Vec3::Y),
-            ..default()
-        });
+        .insert(*/(
+            Camera3d::default(),
+            Transform::from_xyz(0., 8.0, 2.5).looking_at(Vec3::new(0.0, 0.5, 0.0), Vec3::Y),
+        ));
 }
 
 fn setup_target(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
     commands
-        .spawn(PbrBundle {
-            mesh: meshes.add(Mesh::from(Sphere::new(0.1))),
-            material: materials.add(Color::srgb(1.0, 0.0, 0.0)),
-            transform: Transform::from_xyz(0.0, 0., 0.0),
-            ..Default::default()
-        })
+        .spawn((
+            Mesh3d(meshes.add(Mesh::from(Sphere::new(0.1)))),
+            MeshMaterial3d(materials.add(Color::srgb(1.0, 0.0, 0.0))),
+            Transform::from_xyz(0.0, 0., 0.0),
+        ))
         .insert(Target);
 }
 
-fn camera_follow(
+/*fn camera_follow(
     mut camera_query: Query<&mut LookTransform, (With<Camera>, Without<ControlledPlayer>)>,
     player_query: Query<&Transform, With<ControlledPlayer>>,
 ) {
@@ -339,3 +333,4 @@ fn camera_follow(
         cam_transform.target = player_transform.translation;
     }
 }
+*/