Merge pull request #59 from GabrielCarpr/main

splashdust · web-flow · commit 83ad66c5d91f · 2025-05-07T17:18:23.000+02:00
Upgrade to Bevy 0.16
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,7 +17,7 @@ categories = ["game-development", "graphics"]
 opt-level = 3
 
 [dependencies]
-bevy = { version = "0.15", features = [
+bevy = { version = "0.16", features = [
     "bevy_render",
     "bevy_asset",
     "bevy_pbr",
@@ -29,7 +29,8 @@ rand = "0.9.0"
 ahash = "0.8.11"
 weak-table = { version = "0.3.2", features = ["ahash"] }
 noise = { version = "0.9.0", optional = true }
-smooth-bevy-cameras = { version = "0.13.0", optional = true }
+smooth-bevy-cameras = { version = "0.14.0", optional = true }
+hashbrown = "0.15.2"
 
 [dev-dependencies]
 
diff --git a/examples/bombs.rs b/examples/bombs.rs
@@ -1,4 +1,4 @@
-use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*, utils::HashMap};
+use bevy::{pbr::CascadeShadowConfigBuilder, platform::collections::HashMap, prelude::*};
 use bevy_voxel_world::prelude::*;
 use noise::{HybridMulti, NoiseFn, Perlin};
 use std::{sync::Arc, time::Duration};
@@ -77,6 +77,7 @@ fn setup(mut commands: Commands) {
     commands.insert_resource(AmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 100.0,
+        affects_lightmapped_meshes: true,
     });
 }
 
@@ -131,8 +132,9 @@ fn move_camera(
     time: Res<Time>,
     mut cam_transform: Query<&mut Transform, With<VoxelWorldCamera<MainWorld>>>,
 ) {
-    cam_transform.single_mut().translation.x += time.delta_secs() * 7.0;
-    cam_transform.single_mut().translation.z += time.delta_secs() * 12.0;
+    let mut transform = cam_transform.get_single_mut().unwrap();
+    transform.translation.x += time.delta_secs() * 7.0;
+    transform.translation.z += time.delta_secs() * 12.0;
 }
 
 fn explosion(
diff --git a/examples/custom_meshing.rs b/examples/custom_meshing.rs
@@ -6,6 +6,7 @@ use bevy::{
         wireframe::{WireframeConfig, WireframePlugin},
         CascadeShadowConfigBuilder,
     },
+    platform::collections::HashMap,
     prelude::*,
     render::{
         mesh::{Indices, VertexAttributeValues},
@@ -14,7 +15,6 @@ use bevy::{
         settings::{RenderCreation, WgpuSettings},
         RenderPlugin,
     },
-    utils::HashMap,
 };
 
 use bevy_voxel_world::{
@@ -172,7 +172,7 @@ fn main() {
                 }),
                 ..default()
             }),
-            WireframePlugin,
+            WireframePlugin::default(),
         ))
         .add_plugins(VoxelWorldPlugin::with_config(MainWorld))
         .insert_resource(WireframeConfig {
@@ -210,6 +210,7 @@ fn setup(mut commands: Commands) {
     commands.insert_resource(AmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 100.0,
+        affects_lightmapped_meshes: true,
     });
 }
 
@@ -258,6 +259,7 @@ fn move_camera(
     time: Res<Time>,
     mut cam_transform: Query<&mut Transform, With<VoxelWorldCamera<MainWorld>>>,
 ) {
-    cam_transform.single_mut().translation.x += time.delta_secs() * 5.0;
-    cam_transform.single_mut().translation.z += time.delta_secs() * 10.0;
+    let mut transform = cam_transform.single_mut().unwrap();
+    transform.translation.x += time.delta_secs() * 5.0;
+    transform.translation.z += time.delta_secs() * 10.0;
 }
diff --git a/examples/fast_traversal_ray.rs b/examples/fast_traversal_ray.rs
@@ -144,13 +144,13 @@ fn update_cursor_cube(
 ) {
     for ev in cursor_evr.read() {
         // Get a ray from the cursor position into the world
-        let (camera, cam_gtf) = camera_info.single();
+        let (camera, cam_gtf) = camera_info.single().unwrap();
         let Ok(ray) = camera.viewport_to_world(cam_gtf, ev.position) else {
             return;
         };
 
         if let Some(result) = voxel_world_raycast.raycast(ray, &|(_pos, _vox)| true) {
-            let (mut transform, mut cursor_cube) = cursor_cube.single_mut();
+            let (mut transform, mut cursor_cube) = cursor_cube.single_mut().unwrap();
 
             // Camera could end up inside geometry - in that case just ignore the trace
             if let Some(normal) = result.normal {
@@ -216,7 +216,9 @@ fn inputs(
     if keys.just_released(KeyCode::ControlLeft) {
         trace.start = None;
     } else if keys.pressed(KeyCode::ControlLeft) && keys.just_pressed(KeyCode::KeyE) {
-        let cursor = cursor_cube.single();
+        let Ok(cursor) = cursor_cube.single() else {
+            return;
+        };
         let trace_end = cursor.voxel_pos.as_vec3() + Vec3::splat(VOXEL_SIZE / 2.);
 
         voxel_line_traversal(
@@ -233,7 +235,9 @@ fn inputs(
     }
 
     if buttons.just_pressed(MouseButton::Left) {
-        let cursor = cursor_cube.single();
+        let Ok(cursor) = cursor_cube.single() else {
+            return;
+        };
 
         if keys.pressed(KeyCode::ControlLeft) {
             trace.start = Some(cursor.voxel_pos.as_vec3() + Vec3::splat(VOXEL_SIZE / 2.))
diff --git a/examples/multiple_worlds.rs b/examples/multiple_worlds.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use bevy::{
     pbr::{CascadeShadowConfigBuilder, MaterialPipeline, MaterialPipelineKey},
+    platform::collections::HashMap,
     prelude::*,
     render::{
         mesh::MeshVertexBufferLayoutRef,
@@ -10,7 +11,6 @@ use bevy::{
             SpecializedMeshPipelineError,
         },
     },
-    utils::HashMap,
 };
 use bevy_voxel_world::{
     prelude::*,
@@ -111,6 +111,7 @@ fn setup(mut commands: Commands, mut second_world: VoxelWorld<SecondWorld>) {
     commands.insert_resource(AmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 100.0,
+        affects_lightmapped_meshes: true,
     });
 
     // Set some voxels in the second world
diff --git a/examples/noise_terrain.rs b/examples/noise_terrain.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*, utils::HashMap};
+use bevy::{pbr::CascadeShadowConfigBuilder, platform::collections::HashMap, prelude::*};
 use bevy_voxel_world::prelude::*;
 use noise::{HybridMulti, NoiseFn, Perlin};
 
@@ -67,6 +67,7 @@ fn setup(mut commands: Commands) {
     commands.insert_resource(AmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 100.0,
+        affects_lightmapped_meshes: true,
     });
 }
 
@@ -115,6 +116,9 @@ fn move_camera(
     time: Res<Time>,
     mut cam_transform: Query<&mut Transform, With<VoxelWorldCamera<MainWorld>>>,
 ) {
-    cam_transform.single_mut().translation.x += time.delta_secs() * 30.0;
-    cam_transform.single_mut().translation.z += time.delta_secs() * 60.0;
+    let Ok(mut transform) = cam_transform.get_single_mut() else {
+        return;
+    };
+    transform.translation.x += time.delta_secs() * 30.0;
+    transform.translation.z += time.delta_secs() * 60.0;
 }
diff --git a/examples/ray_cast.rs b/examples/ray_cast.rs
@@ -113,13 +113,13 @@ fn update_cursor_cube(
 ) {
     for ev in cursor_evr.read() {
         // Get a ray from the cursor position into the world
-        let (camera, cam_gtf) = camera_info.single();
+        let (camera, cam_gtf) = camera_info.single().unwrap();
         let Ok(ray) = camera.viewport_to_world(cam_gtf, ev.position) else {
             return;
         };
 
         if let Some(result) = voxel_world_raycast.raycast(ray, &|(_pos, _vox)| true) {
-            let (mut transform, mut cursor_cube) = cursor_cube.single_mut();
+            let (mut transform, mut cursor_cube) = cursor_cube.single_mut().unwrap();
             // Move the cursor cube to the position of the voxel we hit
             // Camera is by construction not in a solid voxel, so result.normal must be Some(...)
             let voxel_pos = result.position + result.normal.unwrap();
@@ -135,7 +135,7 @@ fn mouse_button_input(
     cursor_cube: Query<&CursorCube>,
 ) {
     if buttons.just_pressed(MouseButton::Left) {
-        let vox_pos = cursor_cube.single().voxel_pos;
-        voxel_world.set_voxel(vox_pos, WorldVoxel::Solid(FULL_BRICK));
+        let vox = cursor_cube.single().unwrap();
+        voxel_world.set_voxel(vox.voxel_pos, WorldVoxel::Solid(FULL_BRICK));
     }
 }
diff --git a/examples/set_voxel.rs b/examples/set_voxel.rs
@@ -24,6 +24,7 @@ fn setup(mut commands: Commands) {
     commands.insert_resource(AmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 1000.0,
+        affects_lightmapped_meshes: true,
     });
 }
 
@@ -48,7 +49,7 @@ fn move_camera(
     time: Res<Time>,
     mut query: Query<&mut Transform, With<VoxelWorldCamera<DefaultWorld>>>,
 ) {
-    let mut transform = query.single_mut();
+    let mut transform = query.single_mut().unwrap();
     let time_seconds = time.elapsed_secs();
     transform.translation.x = 25.0 * (time_seconds * 0.1).sin();
     transform.translation.z = 25.0 * (time_seconds * 0.1).cos();
diff --git a/src/chunk.rs b/src/chunk.rs
@@ -1,4 +1,6 @@
-use bevy::{prelude::*, render::primitives::Aabb, tasks::Task, utils::HashSet};
+use bevy::{
+    platform::collections::HashSet, prelude::*, render::primitives::Aabb, tasks::Task,
+};
 use ndshape::{ConstShape, ConstShape3u32};
 use std::{
     hash::{Hash, Hasher},
diff --git a/src/chunk_map.rs b/src/chunk_map.rs
@@ -11,8 +11,8 @@ use crate::{
 use bevy::{
     math::{bounding::Aabb3d, Vec3A},
     prelude::*,
-    utils::hashbrown::HashMap,
 };
+use hashbrown::HashMap;
 
 #[derive(Deref, DerefMut)]
 pub struct ChunkMapData<I> {
@@ -119,7 +119,7 @@ impl<C: Send + Sync + 'static, I: Copy> ChunkMap<C, I> {
                     write_lock.bounds.max = position_f.max(write_lock.bounds.max);
                 }
 
-                ev_chunk_will_spawn.send((*evt).clone());
+                ev_chunk_will_spawn.write((*evt).clone());
             }
             update_buffer.clear();
 
diff --git a/src/mesh_cache.rs b/src/mesh_cache.rs
@@ -3,7 +3,7 @@ use std::{
     sync::{Arc, RwLock, Weak},
 };
 
-use bevy::{prelude::*, utils::HashMap};
+use bevy::{platform::collections::HashMap, prelude::*};
 use weak_table::WeakValueHashMap;
 
 use crate::prelude::VoxelWorldConfig;
@@ -32,7 +32,7 @@ pub(crate) struct MeshCache<C: VoxelWorldConfig> {
 
 impl<C: VoxelWorldConfig> MeshCache<C> {
     pub fn apply_buffers(&self, insert_buffer: &mut MeshCacheInsertBuffer<C>) {
-        if insert_buffer.len() == 0 {
+        if insert_buffer.is_empty() {
             return;
         }
 
diff --git a/src/meshing.rs b/src/meshing.rs
@@ -91,7 +91,7 @@ pub fn mesh_from_quads<I: PartialEq + Copy>(
                 WorldVoxel::Solid(mt) => texture_index_mapper(mt),
                 _ => [0, 0, 0],
             };
-            material_types.extend(std::iter::repeat(material_type).take(4));
+            material_types.extend(std::iter::repeat_n(material_type, 4));
         }
     }
 
diff --git a/src/voxel_material.rs b/src/voxel_material.rs
@@ -1,4 +1,5 @@
 use bevy::{
+    asset::weak_handle,
     pbr::{MaterialExtension, MaterialExtensionKey, MaterialExtensionPipeline},
     prelude::*,
     reflect::TypePath,
@@ -24,7 +25,7 @@ pub(crate) struct LoadingTexture {
 pub(crate) struct TextureLayers(pub u32);
 
 pub const VOXEL_TEXTURE_SHADER_HANDLE: Handle<Shader> =
-    Handle::weak_from_u128(6998301138411443008);
+    weak_handle!("df1398dc-56ad-4cd7-9bc2-7678cab2f144");
 
 pub const ATTRIBUTE_TEX_INDEX: MeshVertexAttribute =
     MeshVertexAttribute::new("TextureIndex", 989640910, VertexFormat::Uint32x3);
diff --git a/src/voxel_world.rs b/src/voxel_world.rs
@@ -288,7 +288,7 @@ impl<C: VoxelWorldConfig> VoxelWorld<'_, C> {
     /// ) {
     ///     for ev in cursor_evr.read() {
     ///         // Get a ray from the cursor position into the world
-    ///         let (camera, cam_gtf) = camera_info.single();
+    ///         let (camera, cam_gtf) = camera_info.single().unwrap();
     ///         let Ok(ray) = camera.viewport_to_world(cam_gtf, ev.position) else {
     ///            return;
     ///         };
diff --git a/src/voxel_world_internal.rs b/src/voxel_world_internal.rs
@@ -4,9 +4,9 @@
 ///
 use bevy::{
     ecs::system::SystemParam,
+    platform::collections::{HashMap, HashSet},
     prelude::*,
     tasks::AsyncComputeTaskPool,
-    utils::{HashMap, HashSet},
 };
 use futures_lite::future;
 use std::{
@@ -104,9 +104,11 @@ where
         camera_info: CameraInfo<C>,
     ) {
         // Panic if no root exists as it is already inserted in the setup.
-        let world_root = world_root.get_single().unwrap();
+        let world_root = world_root.single().unwrap();
 
-        let (camera, cam_gtf) = camera_info.single();
+        let Ok((camera, cam_gtf)) = camera_info.single() else {
+            return;
+        };
         let cam_pos = cam_gtf.translation().as_ivec3();
 
         let spawning_distance = configuration.spawning_distance() as i32;
@@ -244,7 +246,7 @@ where
         let spawning_distance = configuration.spawning_distance() as i32;
         let spawning_distance_squared = spawning_distance.pow(2);
 
-        let (_, cam_gtf) = camera_info.get_single().unwrap();
+        let (_, cam_gtf) = camera_info.single().unwrap();
         let cam_pos = cam_gtf.translation().as_ivec3();
 
         let chunk_at_camera = cam_pos / CHUNK_SIZE_I;
@@ -276,7 +278,7 @@ where
             commands.entity(chunk.entity).try_insert(NeedsDespawn);
 
             ev_chunk_will_despawn
-                .send(ChunkWillDespawn::<C>::new(chunk.position, chunk.entity));
+                .write(ChunkWillDespawn::<C>::new(chunk.position, chunk.entity));
         }
     }
 
@@ -293,7 +295,7 @@ where
                 &chunk.position,
                 &read_lock,
             ) {
-                commands.entity(entity).despawn_recursive();
+                commands.entity(entity).despawn();
                 chunk_map_remove_buffer.push(chunk.position);
             }
         }
@@ -357,7 +359,7 @@ where
                 .remove::<NeedsRemesh>();
 
             ev_chunk_will_remesh
-                .send(ChunkWillRemesh::<C>::new(chunk.position, chunk.entity));
+                .write(ChunkWillRemesh::<C>::new(chunk.position, chunk.entity));
         }
     }
 
@@ -484,15 +486,15 @@ where
             if let Some(chunk_data) =
                 ChunkMap::<C, C::MaterialIndex>::get(&chunk_pos, &chunk_map_read_lock)
             {
-                if let Some(mut ent) = commands.get_entity(chunk_data.entity) {
+                if let Ok(mut ent) = commands.get_entity(chunk_data.entity) {
                     ent.try_insert(NeedsRemesh);
                     updated_chunks.insert((chunk_data.entity, chunk_pos));
                 }
             }
         }
 
         for (entity, chunk_pos) in updated_chunks {
-            ev_chunk_will_update.send(ChunkWillUpdate::<C>::new(chunk_pos, entity));
+            ev_chunk_will_update.write(ChunkWillUpdate::<C>::new(chunk_pos, entity));
         }
 
         buffer.clear();
