Merge branch 'main' into wasm-support

Author: splashdust

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.15.2
+
+- Fix: `set_voxel` now queues loaded neighboring chunks for remeshing when a changed voxel is part of their padded chunk data. This keeps meshes correct across chunk boundaries without requiring user code to manually mark adjacent chunks.
+
 ## 0.15.1
 
 - Fix: `set_voxel` no longer triggers a chunk remesh when the written value is identical to the current value. Previously, writing the same voxel value every frame would cause perpetual remesh cancellation — the in-progress async meshing task was dropped each frame before completion, preventing the chunk from ever rendering.

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "bevy_voxel_world"
 description = "A voxel world plugin for Bevy"
-version = "0.15.1"
+version = "0.15.2"
 edition = "2021"
 authors = ["Joacim Magnusson <joacim@isogram.se>"]
 license = "MIT OR Apache-2.0"
@@ -28,7 +28,6 @@ path = "examples/noise_terrain.rs"
 [[example]]
 name = "noise_terrain_lod"
 path = "examples/noise_terrain_lod.rs"
-required-features = ["noise"]
 
 [[example]]
 name = "custom_meshing"
@@ -56,7 +55,7 @@ bevy = { version = "0.18", features = [
 bevy_shader = "0.18"
 block-mesh = "0.2.0"
 futures-lite = "2.6.1"
-hashbrown = "0.16.1"
+hashbrown = "0.17.0"
 ndshape = "0.3.0"
 rand = "0.9.2"
 weak-table = { version = "0.3.2", features = ["ahash"] }

Cargo.toml

@@ -97,7 +97,7 @@ impl VoxelWorldConfig for MainWorld {
                     let mut tex_coords = Vec::with_capacity(num_vertices);
                     let mut material_types = Vec::with_capacity(num_vertices);
 
-                    for (group, face) in buffer.quads.groups.into_iter().zip(faces.into_iter()) {
+                    for (group, face) in buffer.quads.groups.into_iter().zip(faces) {
                         for quad in group.into_iter() {
                             let _normal = IVec3::from([
                                 face.signed_normal().x,

examples/custom_meshing.rs

@@ -90,6 +90,7 @@ fn setup(mut commands: Commands) {
     });
 }
 
+#[allow(clippy::type_complexity)]
 fn get_voxel_fn() -> Box<
     dyn FnMut(IVec3, Option<WorldVoxel<BlockTexture>>) -> WorldVoxel<BlockTexture>
         + Send

examples/multiple_noise_terrain.rs

@@ -202,7 +202,7 @@ fn setup(mut commands: Commands, mut fonts: ResMut<Assets<Font>>) {
     ));
 
     // Ambient light, same color as sun
-    commands.insert_resource(AmbientLight {
+    commands.insert_resource(GlobalAmbientLight {
         color: Color::srgb(0.98, 0.95, 0.82),
         brightness: 100.0,
         affects_lightmapped_meshes: true,

examples/noise_terrain_lod.rs

@@ -114,7 +114,7 @@ fn mesh_from_quads_for_shape<I: PartialEq + Copy>(
 
     let voxel_size = voxel_size_from_shape(shape);
 
-    for (group, face) in quads.groups.into_iter().zip(faces.into_iter()) {
+    for (group, face) in quads.groups.into_iter().zip(faces) {
         for quad in group.into_iter() {
             let quad = Into::<block_mesh::geometry::UnorientedQuad>::into(quad);
             let normal = IVec3::from([

src/meshing.rs

@@ -1,15 +1,19 @@
 use bevy::mesh::VertexAttributeValues;
 use bevy::prelude::*;
-use std::sync::Arc;
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
 
-use crate::chunk_map::ChunkMapUpdateBuffer;
+use crate::chunk_map::{ChunkMapInsertBuffer, ChunkMapUpdateBuffer};
 use crate::configuration::VoxelWorldConfig;
 use crate::mesh_cache::MeshCacheInsertBuffer;
 use crate::meshing::generate_chunk_mesh_for_shape;
 use crate::prelude::*;
 use crate::voxel_traversal::voxel_line_traversal;
 use crate::{
-    chunk::{ChunkData, ChunkTask, FillType, CHUNK_SIZE_F, PADDED_CHUNK_SIZE},
+    chunk::{
+        Chunk, ChunkData, ChunkTask, FillType, CHUNK_SIZE_F, CHUNK_SIZE_I,
+        PADDED_CHUNK_SIZE,
+    },
     prelude::VoxelWorldCamera,
     voxel_world::*,
     voxel_world_internal::ModifiedVoxels,
@@ -208,6 +212,126 @@ fn chunk_will_update_event() {
     app.update();
 }
 
+#[test]
+fn affected_chunk_positions_include_padding_neighbors() {
+    let affected: HashSet<_> = get_affected_chunk_positions(IVec3::new(0, 0, 0))
+        .into_iter()
+        .collect();
+    let expected = HashSet::from([
+        IVec3::new(0, 0, 0),
+        IVec3::new(0, 0, -1),
+        IVec3::new(0, -1, 0),
+        IVec3::new(0, -1, -1),
+        IVec3::new(-1, 0, 0),
+        IVec3::new(-1, 0, -1),
+        IVec3::new(-1, -1, 0),
+        IVec3::new(-1, -1, -1),
+    ]);
+
+    assert_eq!(affected, expected);
+
+    assert_eq!(
+        get_affected_chunk_positions(IVec3::new(1, 1, 1)),
+        vec![IVec3::new(0, 0, 0)]
+    );
+
+    let affected: HashSet<_> =
+        get_affected_chunk_positions(IVec3::new(CHUNK_SIZE_I - 1, 1, 1))
+            .into_iter()
+            .collect();
+    let expected = HashSet::from([IVec3::new(0, 0, 0), IVec3::new(1, 0, 0)]);
+
+    assert_eq!(affected, expected);
+}
+
+#[test]
+fn set_voxel_on_chunk_boundary_marks_padding_neighbors_for_remesh() {
+    let expected = HashSet::from([
+        IVec3::new(0, 0, 0),
+        IVec3::new(0, 0, -1),
+        IVec3::new(0, -1, 0),
+        IVec3::new(0, -1, -1),
+        IVec3::new(-1, 0, 0),
+        IVec3::new(-1, 0, -1),
+        IVec3::new(-1, -1, 0),
+        IVec3::new(-1, -1, -1),
+    ]);
+
+    let mut app = App::new();
+    app.add_plugins((MinimalPlugins, VoxelWorldPlugin::<DefaultWorld>::minimal()));
+    let camera_transform =
+        Transform::from_xyz(10.0, 10.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y);
+    app.world_mut().spawn((
+        Camera::default(),
+        Camera3d::default(),
+        camera_transform,
+        GlobalTransform::from(camera_transform),
+        VoxelWorldCamera::<DefaultWorld>::default(),
+    ));
+    app.update();
+
+    type Mat = <DefaultWorld as VoxelWorldConfig>::MaterialIndex;
+    let mut chunks = Vec::new();
+    for chunk_pos in expected.iter().copied() {
+        let entity = app.world_mut().spawn_empty().id();
+        let shape = UVec3::splat(PADDED_CHUNK_SIZE);
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(Chunk::<DefaultWorld>::new(
+                chunk_pos, 0, entity, shape, shape,
+            ));
+        chunks.push((chunk_pos, ChunkData::<Mat>::with_entity(entity)));
+    }
+
+    app.world_mut()
+        .resource_mut::<ChunkMapInsertBuffer<DefaultWorld, Mat>>()
+        .extend(chunks);
+    app.update();
+    for _ in 0..100 {
+        app.update();
+    }
+
+    app.world_mut()
+        .resource_mut::<Messages<ChunkWillRemesh<DefaultWorld>>>()
+        .clear();
+
+    let remeshed_chunks = Arc::new(Mutex::new(Vec::new()));
+    let remeshed_chunks_writer = remeshed_chunks.clone();
+    app.add_systems(
+        Update,
+        move |mut events: MessageReader<ChunkWillRemesh<DefaultWorld>>| {
+            remeshed_chunks_writer
+                .lock()
+                .unwrap()
+                .extend(events.read().map(|event| event.chunk_key));
+        },
+    );
+
+    app.add_systems(
+        Update,
+        |mut voxel_world: VoxelWorld<DefaultWorld>, mut did_set: Local<bool>| {
+            if *did_set {
+                return;
+            }
+
+            voxel_world.set_voxel(IVec3::new(0, 0, 0), WorldVoxel::Solid(1));
+            *did_set = true;
+        },
+    );
+
+    app.update();
+    app.update();
+    app.update();
+
+    let remeshed_chunks: HashSet<_> =
+        remeshed_chunks.lock().unwrap().iter().copied().collect();
+
+    assert!(
+        expected.is_subset(&remeshed_chunks),
+        "expected {expected:?} to be remeshed, got {remeshed_chunks:?}"
+    );
+}
+
 #[test]
 fn chunk_generate_reuses_previous_data_when_configured() {
     type Mat = <DefaultWorld as VoxelWorldConfig>::MaterialIndex;

src/test.rs

@@ -8,7 +8,7 @@ use std::sync::Arc;
 use bevy::{ecs::system::SystemParam, math::bounding::RayCast3d, prelude::*};
 
 use crate::{
-    chunk::{ChunkData, CHUNK_SIZE_F, CHUNK_SIZE_I},
+    chunk::{ChunkData, CHUNK_SIZE_F, CHUNK_SIZE_I, CHUNK_SIZE_U},
     chunk_map::ChunkMap,
     configuration::VoxelWorldConfig,
     traversal_alg::voxel_line_traversal,
@@ -404,3 +404,38 @@ pub fn get_chunk_voxel_position(position: IVec3) -> (IVec3, UVec3) {
 
     (chunk_position, voxel_position)
 }
+
+/// Returns every chunk whose padded voxel data includes the given world-space voxel.
+pub(crate) fn get_affected_chunk_positions(position: IVec3) -> Vec<IVec3> {
+    let (chunk_position, voxel_position) = get_chunk_voxel_position(position);
+
+    let axis_offsets = |component| {
+        let mut offsets = [0, 0, 0];
+        let mut len = 1;
+
+        if component == 1 {
+            offsets[len] = -1;
+            len += 1;
+        }
+        if component == CHUNK_SIZE_U {
+            offsets[len] = 1;
+            len += 1;
+        }
+
+        (offsets, len)
+    };
+
+    let (x_offsets, x_len) = axis_offsets(voxel_position.x);
+    let (y_offsets, y_len) = axis_offsets(voxel_position.y);
+    let (z_offsets, z_len) = axis_offsets(voxel_position.z);
+    let mut affected_chunks = Vec::with_capacity(8);
+    for x in x_offsets.iter().take(x_len).copied() {
+        for y in y_offsets.iter().take(y_len).copied() {
+            for z in z_offsets.iter().take(z_len).copied() {
+                affected_chunks.push(chunk_position + IVec3::new(x, y, z));
+            }
+        }
+    }
+
+    affected_chunks
+}

src/voxel_world.rs

@@ -25,8 +25,8 @@ use crate::{
     voxel::WorldVoxel,
     voxel_material::LoadingTexture,
     voxel_world::{
-        get_chunk_voxel_position, ChunkWillChangeLod, ChunkWillDespawn, ChunkWillRemesh,
-        ChunkWillSpawn, ChunkWillUpdate, VoxelWorldCamera,
+        get_affected_chunk_positions, ChunkWillChangeLod, ChunkWillDespawn,
+        ChunkWillRemesh, ChunkWillSpawn, ChunkWillUpdate, VoxelWorldCamera,
     },
 };
 
@@ -411,17 +411,13 @@ where
     ) {
         let thread_pool = AsyncComputeTaskPool::get();
         let max_threads = configuration.max_active_chunk_threads();
-        let mut active_threads = chunk_threads.iter().count();
+        let remaining_threads = max_threads.saturating_sub(chunk_threads.iter().count());
 
-        if max_threads == 0 {
+        if remaining_threads == 0 {
             return;
         }
 
-        for chunk in dirty_chunks.iter() {
-            if active_threads >= max_threads {
-                break;
-            }
-
+        for chunk in dirty_chunks.iter().take(remaining_threads) {
             let previous_chunk_data = {
                 let read_lock = chunk_map.get_read_lock();
                 ChunkMap::<C, C::MaterialIndex>::get(&chunk.position, &read_lock)
@@ -492,8 +488,6 @@ where
                 ))
                 .remove::<NeedsRemesh>();
 
-            active_threads += 1;
-
             ev_chunk_will_remesh
                 .write(ChunkWillRemesh::<C>::new(chunk.position, chunk.entity));
         }
@@ -621,17 +615,18 @@ where
                 continue;
             }
 
-            let (chunk_pos, _vox_pos) = get_chunk_voxel_position(*position);
             modified_voxels.insert(*position, *voxel);
 
-            // Mark the chunk as needing remeshing or spawn a new chunk if it doesn't exist
-            if let Some(chunk_data) =
-                ChunkMap::<C, C::MaterialIndex>::get(&chunk_pos, &chunk_map_read_lock)
-            {
-                if let Ok(mut ent) = commands.get_entity(chunk_data.entity) {
-                    ent.try_insert(NeedsRemesh);
-                    ent.remove::<ChunkThread<C, C::MaterialIndex>>();
-                    updated_chunks.insert((chunk_data.entity, chunk_pos));
+            for affected_chunk_pos in get_affected_chunk_positions(*position) {
+                if let Some(chunk_data) = ChunkMap::<C, C::MaterialIndex>::get(
+                    &affected_chunk_pos,
+                    &chunk_map_read_lock,
+                ) {
+                    if let Ok(mut ent) = commands.get_entity(chunk_data.entity) {
+                        ent.try_insert(NeedsRemesh);
+                        ent.remove::<ChunkThread<C, C::MaterialIndex>>();
+                        updated_chunks.insert((chunk_data.entity, affected_chunk_pos));
+                    }
                 }
             }
         }