switch to noise lib that works on arm neon (apple)

src/server/chunk.rs

@@ -3,8 +3,9 @@ use std::collections::{HashMap, HashSet};
 use bevy_ecs::{entity::Entity, system::Commands};
 
 use crate::{
-    common::component::{ChunkBundle, ChunkData, ChunkMesh, ChunkPos}, server::generation::generate_tree, util::
-        thread::{ExitType, ThreadChannel, ThreadHandle}
+    common::component::{ChunkBundle, ChunkData, ChunkMesh, ChunkPos},
+    server::generation::generate_tree,
+    util::{oct_tree::OctTree, thread::{ExitType, ThreadChannel, ThreadHandle}},
 };
 
 pub struct ChunkManager {
@@ -107,7 +108,14 @@ fn chunk_loader_main(channel: ThreadChannel<ServerChunkMsg, ChunkLoaderMsg>) {
                 let tree = ChunkData::from_tree(generate_tree(pos));
                 let tree_time = std::time::Instant::now() - start;
 
-                println!("gen time: {:<5?}; size: {}", tree_time, tree.raw().len());
+                // let worst = OctTree::from_fn(f_leaf, f_node, levels);
+
+                println!(
+                    "gen time: {:<5?}; size: {} nodes = {} bytes",
+                    tree_time,
+                    tree.raw().len(),
+                    std::mem::size_of_val(tree.raw())
+                );
 
                 channel.send(ServerChunkMsg::ChunkGenerated(GeneratedChunk {
                     pos,
@@ -121,4 +129,3 @@ fn chunk_loader_main(channel: ThreadChannel<ServerChunkMsg, ChunkLoaderMsg>) {
         }
     }
 }
-

src/server/chunk/mod.rs

@@ -1,2 +0,0 @@
-mod load;
-pub use load::*;

src/server/generation/mod.rs

@@ -1,5 +1,5 @@
+use fastnoise_simd::FastNoiseSIMD;
 use nalgebra::Vector3;
-use simdnoise::NoiseBuilder;
 
 use crate::{
     common::component::{chunk, ChunkPos},
@@ -11,11 +11,11 @@ pub fn generate_tree(pos: ChunkPos) -> OctTree {
         return OctTree::from_leaf(0, 8);
     }
     let posf: Vector3<f32> = pos.cast() * chunk::SIDE_LENGTH as f32;
-    let noise1 = generate_noise_map(0, 1.0, posf, chunk::SCALE, &mut |v: f32| {
+    let noise1 = generate_noise_map(2, 1.0, posf, chunk::SCALE, &mut |v: f32| {
         (v * 2.0).exp2() * TOP * 0.25
     });
-    let noise2 = generate_noise_map(1, 50.0, posf, chunk::SCALE, &mut |v: f32| v * 20.0 + GRASS);
-    OctTree::from_fn_rec(
+    let noise2 = generate_noise_map(0, 50.0, posf, chunk::SCALE, &mut |v: f32| v * 20.0 + GRASS);
+    OctTree::from_fn(
         &mut |p| generate_leaf(p, posf, (&noise1.base, &noise2.base)),
         &mut |p, lvl| generate_node(p, lvl, posf, (&noise1, &noise2)),
         chunk::SCALE,
@@ -89,10 +89,15 @@ fn generate_noise_map(
     adjust: &mut impl FnMut(f32) -> f32,
 ) -> NoiseMap {
     let mut size = 2usize.pow(levels);
-    let (mut base, min, max) = NoiseBuilder::gradient_2d_offset(posf.x, size, posf.z, size)
-        .with_seed(seed)
-        .with_freq(freq / (size as f32))
-        .generate();
+    let posi = Vector3::new(posf.x as i32, posf.y as i32, posf.z as i32);
+    let noise = FastNoiseSIMD::new(seed).get_simplex_set(posi.x, posi.y, posi.z, size as i32, size as i32, 1, freq * 150.0 / size as f32);
+    let mut base = noise.as_vec();
+    let (mut min, mut max) = (f32::MAX, f32::MIN);
+    for v in &base {
+        min = v.min(min);
+        max = v.max(max);
+    }
+    println!("{min}, {max}");
     for v in &mut base {
         *v = adjust((*v - min) / (max - min));
     }