chore: parse double perlin noise samplers amplitude at compile time

pumpkin-codegen/src/block.rs

@@ -641,8 +641,6 @@ pub struct Block {
     pub states: Vec<BlockState>,
     /// Experience points dropped when the block is mined, if any.
     pub experience: Option<Experience>,
-    /// Calculated property descriptors for the block.
-    pub property_descriptors: Vec<TokenStream>,
 }
 
 impl ToTokens for Block {
@@ -685,7 +683,6 @@ impl ToTokens for Block {
         } else {
             quote! { None }
         };
-        let property_descriptors = &self.property_descriptors;
         tokens.extend(quote! {
             Block {
                 id: #id,
@@ -698,7 +695,6 @@ impl ToTokens for Block {
                 item_id: #item_id,
                 default_state: &#default_state,
                 states: &[#(#states),*],
-                properties: &[#(#property_descriptors),*],
                 flammable: #flammable,
                 loot_table: #loot_table,
                 experience: #experience,
@@ -898,11 +894,11 @@ pub fn build() -> TokenStream {
         let id_lit = LitInt::new(&block.id.to_string(), Span::call_site());
         let item_id = block.item_id;
 
-        let mut block_with_descriptors = block.clone();
+        // let mut block_with_descriptors = block.clone();
-        block_with_descriptors.property_descriptors = property_descriptors;
+        // block_with_descriptors.property_descriptors = property_descriptors;
 
         constants_list.push(quote! {
-            pub const #const_ident: Block = #block_with_descriptors;
+            pub const #const_ident: Block = #block;
         });
 
         type_from_raw_id_array.push((block.id, quote! { &Self::#const_ident }));

pumpkin-codegen/src/configured_feature.rs

@@ -860,10 +860,24 @@ fn value_to_dpnp(v: &Value) -> TokenStream {
         .as_array()
         .map(|a| a.iter().filter_map(|x| x.as_f64()).collect())
         .unwrap_or_default();
+    let mut min_octave = i32::MAX;
+    let mut max_octave = i32::MIN;
+
+    for (index, amp) in amplitudes.iter().enumerate() {
+        if *amp != 0.0 {
+            min_octave = i32::min(min_octave, index as i32);
+            max_octave = i32::max(max_octave, index as i32);
+        }
+    }
+
+    let octaves = max_octave - min_octave;
+    let create_amp_val = 0.1f64 * (1.0f64 + 1.0f64 / (octaves + 1) as f64);
+    let final_amplitude = 0.16666666666666666f64 / create_amp_val;
     quote! {
         DoublePerlinNoiseParametersCodec {
             first_octave: #first_octave,
             amplitudes: vec![#(#amplitudes),*],
+            amplitude: #final_amplitude,
         }
     }
 }

pumpkin-codegen/src/noise_parameter.rs

@@ -4,35 +4,55 @@ use proc_macro2::TokenStream;
 use pumpkin_util::DoublePerlinNoiseParametersCodec;
 use quote::{format_ident, quote};
 
-/// Generates the `TokenStream` for `DoublePerlinNoiseParameters` constants and its `id_to_parameters` lookup.
 pub fn build() -> TokenStream {
     let json: BTreeMap<String, DoublePerlinNoiseParametersCodec> =
         serde_json::from_str(&fs::read_to_string("../assets/noise_parameters.json").unwrap())
             .expect("Failed to parse noise_parameters.json");
+    
     let mut variants = TokenStream::new();
     let mut match_variants = TokenStream::new();
 
     for (i, (raw_name, parameter)) in json.iter().enumerate() {
-        let name = raw_name
+        let name = raw_name.strip_prefix("minecraft:").unwrap().replace("/", "_");
-            .strip_prefix("minecraft:")
-            .unwrap()
-            .replace("/", "_");
-        let simple_id = name.clone();
         let name_ident = format_ident!("{}", name.to_uppercase());
-        let first_octave = parameter.first_octave;
+        
+        // 1. MD5 Pre-calculation
+        let hash = md5::compute(raw_name.as_bytes());
+        let lo = u64::from_be_bytes(hash[0..8].try_into().unwrap());
+        let hi = u64::from_be_bytes(hash[8..16].try_into().unwrap());
+        
+        // 2. Amplitude Pre-calculation
         let amplitudes = &parameter.amplitudes;
+        let mut min_octave = i32::MAX;
+        let mut max_octave = i32::MIN;
+
+        for (index, amp) in amplitudes.iter().enumerate() {
+            if *amp != 0.0 {
+                min_octave = i32::min(min_octave, index as i32);
+                max_octave = i32::max(max_octave, index as i32);
+            }
+        }
+
+        // Equivalent to your create_amplitude logic
+        let octaves = max_octave - min_octave;
+        let create_amp_val = 0.1f64 * (1.0f64 + 1.0f64 / (octaves + 1) as f64);
+        let final_amplitude = 0.16666666666666666f64 / create_amp_val;
+
+        let first_octave = parameter.first_octave;
 
         variants.extend([quote! {
             pub const #name_ident: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
                 #i,
                 #first_octave,
                 &[#(#amplitudes),*],
-                #raw_name
+                #lo,
+                #hi,
+                #final_amplitude
             );
         }]);
 
         match_variants.extend([quote! {
-            #simple_id => &Self::#name_ident,
+            #name => &Self::#name_ident,
         }]);
     }
     let count = json.len();
@@ -42,27 +62,28 @@ pub fn build() -> TokenStream {
             pub id: usize,
             pub first_octave: i32,
             pub amplitudes: &'static [f64],
-            name: &'static str,
+            pub lo: u64,
+            pub hi: u64,
+            pub amplitude: f64,
         }
 
         impl DoublePerlinNoiseParameters {
             pub const COUNT: usize = #count;
 
-            pub const fn new(id: usize, first_octave: i32, amplitudes: &'static [f64], name: &'static str) -> Self {
+            pub const fn new(
-                Self {
+                id: usize, 
-                    id,
+                first_octave: i32, 
-                    first_octave,
+                amplitudes: &'static [f64], 
-                    amplitudes,
+                lo: u64,
-                    name
+                hi: u64,
-                }
+                amplitude: f64,
+            ) -> Self {
+                Self { id, first_octave, amplitudes, lo, hi, amplitude }
             }
 
-            pub const fn name(&self) -> &'static str {
+            pub fn id_to_parameters(id: &str) -> Option<&'static DoublePerlinNoiseParameters> {
-                self.name
+                let id = id.strip_prefix("minecraft:").unwrap_or(id).replace("/", "_");
-            }
+                Some(match id.as_str() {
-
-            pub fn id_to_parameters(id: &str) -> Option<&DoublePerlinNoiseParameters> {
-                Some(match id {
                     #match_variants
                     _ => return None,
                 })
@@ -70,6 +91,5 @@ pub fn build() -> TokenStream {
 
             #variants
         }
-
     }
 }

pumpkin-data/src/generated/configured_features_generated.rs

@@ -1868,6 +1868,7 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
                     noise: DoublePerlinNoiseParametersCodec {
                         first_octave: 0i32,
                         amplitudes: vec![1f64],
+                        amplitude: 0.8333333333333333f64,
                     },
                     scale: 0.020833334f32,
                 },
@@ -1898,6 +1899,7 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
                         noise: DoublePerlinNoiseParametersCodec {
                             first_octave: -3i32,
                             amplitudes: vec![1f64],
+                            amplitude: 0.8333333333333333f64,
                         },
                         scale: 1f32,
                     },
@@ -1924,6 +1926,7 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
                 slow_noise: DoublePerlinNoiseParametersCodec {
                     first_octave: -10i32,
                     amplitudes: vec![1f64],
+                    amplitude: 0.8333333333333333f64,
                 },
                 slow_scale: 1f64,
             }),
@@ -1948,6 +1951,7 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
                     noise: DoublePerlinNoiseParametersCodec {
                         first_octave: 0i32,
                         amplitudes: vec![1f64],
+                        amplitude: 0.8333333333333333f64,
                     },
                     scale: 0.005f32,
                 },

pumpkin-data/src/generated/noise_parameter.rs

@@ -3,7 +3,9 @@ pub struct DoublePerlinNoiseParameters {
     pub id: usize,
     pub first_octave: i32,
     pub amplitudes: &'static [f64],
-    name: &'static str,
+    pub lo: u64,
+    pub hi: u64,
+    pub amplitude: f64,
 }
 impl DoublePerlinNoiseParameters {
     pub const COUNT: usize = 62usize;
@@ -11,20 +13,25 @@ impl DoublePerlinNoiseParameters {
         id: usize,
         first_octave: i32,
         amplitudes: &'static [f64],
-        name: &'static str,
+        lo: u64,
+        hi: u64,
+        amplitude: f64,
     ) -> Self {
         Self {
             id,
             first_octave,
             amplitudes,
-            name,
+            lo,
+            hi,
+            amplitude,
         }
     }
-    pub const fn name(&self) -> &'static str {
+    pub fn id_to_parameters(id: &str) -> Option<&'static DoublePerlinNoiseParameters> {
-        self.name
+        let id = id
-    }
+            .strip_prefix("minecraft:")
-    pub fn id_to_parameters(id: &str) -> Option<&DoublePerlinNoiseParameters> {
+            .unwrap_or(id)
-        Some(match id {
+            .replace("/", "_");
+        Some(match id.as_str() {
             "aquifer_barrier" => &Self::AQUIFER_BARRIER,
             "aquifer_fluid_level_floodedness" => &Self::AQUIFER_FLUID_LEVEL_FLOODEDNESS,
             "aquifer_fluid_level_spread" => &Self::AQUIFER_FLUID_LEVEL_SPREAD,
@@ -90,89 +97,143 @@ impl DoublePerlinNoiseParameters {
             _ => return None,
         })
     }
-    pub const AQUIFER_BARRIER: DoublePerlinNoiseParameters =
+    pub const AQUIFER_BARRIER: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
-        DoublePerlinNoiseParameters::new(0usize, -3i32, &[1f64], "minecraft:aquifer_barrier");
+        0usize,
+        -3i32,
+        &[1f64],
+        16244762748638791999u64,
+        1391399305011792652u64,
+        0.8333333333333333f64,
+    );
     pub const AQUIFER_FLUID_LEVEL_FLOODEDNESS: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             1usize,
             -7i32,
             &[1f64],
-            "minecraft:aquifer_fluid_level_floodedness",
+            1971819648764795038u64,
+            2506222294934710214u64,
+            0.8333333333333333f64,
         );
     pub const AQUIFER_FLUID_LEVEL_SPREAD: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             2usize,
             -5i32,
             &[1f64],
-            "minecraft:aquifer_fluid_level_spread",
+            644356645385251490u64,
+            3919847117419490415u64,
+            0.8333333333333333f64,
+        );
+    pub const AQUIFER_LAVA: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        3usize,
+        -1i32,
+        &[1f64],
+        1031642243090684786u64,
+        2820617609049802170u64,
+        0.8333333333333333f64,
     );
-    pub const AQUIFER_LAVA: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(3usize, -1i32, &[1f64], "minecraft:aquifer_lava");
     pub const BADLANDS_PILLAR: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         4usize,
         -2i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:badlands_pillar",
+        13493758258311752636u64,
+        3411659937350140381u64,
+        1.3333333333333333f64,
+    );
+    pub const BADLANDS_PILLAR_ROOF: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        5usize,
+        -8i32,
+        &[1f64],
+        7795723110176986287u64,
+        4566391624864518557u64,
+        0.8333333333333333f64,
     );
-    pub const BADLANDS_PILLAR_ROOF: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(5usize, -8i32, &[1f64], "minecraft:badlands_pillar_roof");
     pub const BADLANDS_SURFACE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         6usize,
         -6i32,
         &[1f64, 1f64, 1f64],
-        "minecraft:badlands_surface",
+        18228034071625356340u64,
+        8308134076163360455u64,
+        1.25f64,
     );
     pub const CALCITE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         7usize,
         -9i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:calcite",
+        4904593190305397776u64,
+        1211164448996192585u64,
+        1.3333333333333333f64,
     );
     pub const CAVE_CHEESE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         8usize,
         -8i32,
         &[0.5f64, 1f64, 2f64, 1f64, 2f64, 1f64, 0f64, 2f64, 0f64],
-        "minecraft:cave_cheese",
+        12779255569999112784u64,
+        6029128391830109216u64,
+        1.4814814814814814f64,
     );
     pub const CAVE_ENTRANCE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         9usize,
         -7i32,
         &[0.4f64, 0.5f64, 1f64],
-        "minecraft:cave_entrance",
+        17366031995758287461u64,
+        13627013544070811296u64,
+        1.25f64,
+    );
+    pub const CAVE_LAYER: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        10usize,
+        -8i32,
+        &[1f64],
+        5620043451534219907u64,
+        6506268541312725510u64,
+        0.8333333333333333f64,
+    );
+    pub const CLAY_BANDS_OFFSET: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        11usize,
+        -8i32,
+        &[1f64],
+        7256644037753960286u64,
+        11158743614211970085u64,
+        0.8333333333333333f64,
     );
-    pub const CAVE_LAYER: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(10usize, -8i32, &[1f64], "minecraft:cave_layer");
-    pub const CLAY_BANDS_OFFSET: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(11usize, -8i32, &[1f64], "minecraft:clay_bands_offset");
     pub const CONTINENTALNESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         12usize,
         -9i32,
         &[1f64, 1f64, 2f64, 2f64, 2f64, 1f64, 1f64, 1f64, 1f64],
-        "minecraft:continentalness",
+        9477944837549565538u64,
+        12656866088844454061u64,
+        1.4999999999999998f64,
     );
     pub const CONTINENTALNESS_LARGE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         13usize,
         -11i32,
         &[1f64, 1f64, 2f64, 2f64, 2f64, 1f64, 1f64, 1f64, 1f64],
-        "minecraft:continentalness_large",
+        11114692157640599772u64,
+        17162581654990867885u64,
+        1.4999999999999998f64,
     );
     pub const EROSION: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         14usize,
         -9i32,
         &[1f64, 1f64, 0f64, 1f64, 1f64],
-        "minecraft:erosion",
+        14998273076172386264u64,
+        5157273775208757888u64,
+        1.3888888888888888f64,
     );
     pub const EROSION_LARGE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         15usize,
         -11i32,
         &[1f64, 1f64, 0f64, 1f64, 1f64],
-        "minecraft:erosion_large",
+        10130929960551098705u64,
+        16922189808605746015u64,
+        1.3888888888888888f64,
     );
     pub const GRAVEL: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         16usize,
         -8i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:gravel",
+        1153479925840222391u64,
+        7756889976470315235u64,
+        1.3333333333333333f64,
     );
     pub const GRAVEL_LAYER: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         17usize,
@@ -188,27 +249,41 @@ impl DoublePerlinNoiseParameters {
             0f64,
             0.013333333333333334f64,
         ],
-        "minecraft:gravel_layer",
+        3700753923770560088u64,
+        5824949440647379577u64,
+        1.4999999999999998f64,
     );
     pub const ICE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         18usize,
         -4i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:ice",
+        7994092977778472105u64,
+        16301997149661018038u64,
+        1.3333333333333333f64,
     );
     pub const ICEBERG_PILLAR: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         19usize,
         -6i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:iceberg_pillar",
+        15167922125944621777u64,
+        9215064124946046309u64,
+        1.3333333333333333f64,
+    );
+    pub const ICEBERG_PILLAR_ROOF: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        20usize,
+        -3i32,
+        &[1f64],
+        6714001469876891169u64,
+        17524238621251302951u64,
+        0.8333333333333333f64,
     );
-    pub const ICEBERG_PILLAR_ROOF: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(20usize, -3i32, &[1f64], "minecraft:iceberg_pillar_roof");
     pub const ICEBERG_SURFACE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         21usize,
         -6i32,
         &[1f64, 1f64, 1f64],
-        "minecraft:iceberg_surface",
+        13536647331807014343u64,
+        8721275689436799325u64,
+        1.25f64,
     );
     pub const JAGGED: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         22usize,
@@ -217,89 +292,177 @@ impl DoublePerlinNoiseParameters {
             1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64, 1f64,
             1f64, 1f64,
         ],
-        "minecraft:jagged",
+        17943115692276099476u64,
+        8209175272455791875u64,
+        1.568627450980392f64,
     );
     pub const NETHER_TEMPERATURE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         23usize,
         -7i32,
         &[1f64, 1f64],
-        "minecraft:nether/temperature",
+        4494007131265727292u64,
+        3789417001435421350u64,
+        1.111111111111111f64,
     );
     pub const NETHER_VEGETATION: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         24usize,
         -7i32,
         &[1f64, 1f64],
-        "minecraft:nether/vegetation",
+        10190642735749408132u64,
+        11065819044765107400u64,
+        1.111111111111111f64,
     );
     pub const NETHER_STATE_SELECTOR: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         25usize,
         -4i32,
         &[1f64],
-        "minecraft:nether_state_selector",
+        5940456273400029989u64,
+        11258616162249557280u64,
+        0.8333333333333333f64,
     );
     pub const NETHER_WART: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         26usize,
         -3i32,
         &[1f64, 0f64, 0f64, 0.9f64],
-        "minecraft:nether_wart",
+        17703200590926175663u64,
+        17214184263581656775u64,
+        1.3333333333333333f64,
     );
     pub const NETHERRACK: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         27usize,
         -3i32,
         &[1f64, 0f64, 0f64, 0.35f64],
-        "minecraft:netherrack",
+        10355412640456601864u64,
+        11182414268062555835u64,
+        1.3333333333333333f64,
+    );
+    pub const NOODLE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        28usize,
+        -8i32,
+        &[1f64],
+        15149230821572338763u64,
+        7399974921363027187u64,
+        0.8333333333333333f64,
+    );
+    pub const NOODLE_RIDGE_A: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        29usize,
+        -7i32,
+        &[1f64],
+        9662238534792077350u64,
+        5361047657610944607u64,
+        0.8333333333333333f64,
+    );
+    pub const NOODLE_RIDGE_B: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        30usize,
+        -7i32,
+        &[1f64],
+        16943433826535595665u64,
+        224869257309605468u64,
+        0.8333333333333333f64,
+    );
+    pub const NOODLE_THICKNESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        31usize,
+        -8i32,
+        &[1f64],
+        3433040058802586130u64,
+        6882284535972731025u64,
+        0.8333333333333333f64,
     );
-    pub const NOODLE: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(28usize, -8i32, &[1f64], "minecraft:noodle");
-    pub const NOODLE_RIDGE_A: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(29usize, -7i32, &[1f64], "minecraft:noodle_ridge_a");
-    pub const NOODLE_RIDGE_B: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(30usize, -7i32, &[1f64], "minecraft:noodle_ridge_b");
-    pub const NOODLE_THICKNESS: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(31usize, -8i32, &[1f64], "minecraft:noodle_thickness");
     pub const OFFSET: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         32usize,
         -3i32,
         &[1f64, 1f64, 1f64, 0f64],
-        "minecraft:offset",
+        577895406318539652u64,
+        4557074653038767061u64,
+        1.25f64,
+    );
+    pub const ORE_GAP: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        33usize,
+        -5i32,
+        &[1f64],
+        11262595240165106875u64,
+        13644046979728391006u64,
+        0.8333333333333333f64,
+    );
+    pub const ORE_VEIN_A: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        34usize,
+        -7i32,
+        &[1f64],
+        5537411705652647497u64,
+        14832111794027820525u64,
+        0.8333333333333333f64,
+    );
+    pub const ORE_VEIN_B: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        35usize,
+        -7i32,
+        &[1f64],
+        7720896042651600585u64,
+        12540131182595714753u64,
+        0.8333333333333333f64,
+    );
+    pub const ORE_VEININESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        36usize,
+        -8i32,
+        &[1f64],
+        7748099570268139889u64,
+        15600382243457734180u64,
+        0.8333333333333333f64,
     );
-    pub const ORE_GAP: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(33usize, -5i32, &[1f64], "minecraft:ore_gap");
-    pub const ORE_VEIN_A: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(34usize, -7i32, &[1f64], "minecraft:ore_vein_a");
-    pub const ORE_VEIN_B: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(35usize, -7i32, &[1f64], "minecraft:ore_vein_b");
-    pub const ORE_VEININESS: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(36usize, -8i32, &[1f64], "minecraft:ore_veininess");
     pub const PACKED_ICE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         37usize,
         -7i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:packed_ice",
+        6678935034624176163u64,
+        7587755929013049282u64,
+        1.3333333333333333f64,
     );
     pub const PATCH: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         38usize,
         -5i32,
         &[1f64, 0f64, 0f64, 0f64, 0f64, 0.013333333333333334f64],
-        "minecraft:patch",
+        17102750654369557799u64,
+        2432978389120904123u64,
+        1.4285714285714284f64,
+    );
+    pub const PILLAR: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        39usize,
+        -7i32,
+        &[1f64, 1f64],
+        15338975643228066631u64,
+        14751109933046868508u64,
+        1.111111111111111f64,
+    );
+    pub const PILLAR_RARENESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        40usize,
+        -8i32,
+        &[1f64],
+        10222445372526765264u64,
+        325922074234395002u64,
+        0.8333333333333333f64,
+    );
+    pub const PILLAR_THICKNESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        41usize,
+        -8i32,
+        &[1f64],
+        1884979804952342669u64,
+        14176101322839234188u64,
+        0.8333333333333333f64,
     );
-    pub const PILLAR: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(39usize, -7i32, &[1f64, 1f64], "minecraft:pillar");
-    pub const PILLAR_RARENESS: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(40usize, -8i32, &[1f64], "minecraft:pillar_rareness");
-    pub const PILLAR_THICKNESS: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(41usize, -8i32, &[1f64], "minecraft:pillar_thickness");
     pub const POWDER_SNOW: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         42usize,
         -6i32,
         &[1f64, 1f64, 1f64, 1f64],
-        "minecraft:powder_snow",
+        8439957600881366575u64,
+        7128508063779685469u64,
+        1.3333333333333333f64,
     );
     pub const RIDGE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         43usize,
         -7i32,
         &[1f64, 2f64, 1f64, 0f64, 0f64, 0f64],
-        "minecraft:ridge",
+        17278323085305457460u64,
+        2012804684704589034u64,
+        1.25f64,
     );
     pub const SOUL_SAND_LAYER: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         44usize,
@@ -315,85 +478,149 @@ impl DoublePerlinNoiseParameters {
             0f64,
             0.013333333333333334f64,
         ],
-        "minecraft:soul_sand_layer",
+        12961541884992915651u64,
+        3334122176816136683u64,
+        1.4999999999999998f64,
+    );
+    pub const SPAGHETTI_2D: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        45usize,
+        -7i32,
+        &[1f64],
+        3779800575929599095u64,
+        3026987529072654797u64,
+        0.8333333333333333f64,
     );
-    pub const SPAGHETTI_2D: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(45usize, -7i32, &[1f64], "minecraft:spaghetti_2d");
     pub const SPAGHETTI_2D_ELEVATION: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             46usize,
             -8i32,
             &[1f64],
-            "minecraft:spaghetti_2d_elevation",
+            3016672669024775629u64,
+            6607299245856183467u64,
+            0.8333333333333333f64,
         );
     pub const SPAGHETTI_2D_MODULATOR: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             47usize,
             -11i32,
             &[1f64],
-            "minecraft:spaghetti_2d_modulator",
+            10799755704108864802u64,
+            158433782627262445u64,
+            0.8333333333333333f64,
         );
     pub const SPAGHETTI_2D_THICKNESS: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             48usize,
             -11i32,
             &[1f64],
-            "minecraft:spaghetti_2d_thickness",
+            4027848931106223304u64,
+            16564638782843236028u64,
+            0.8333333333333333f64,
+        );
+    pub const SPAGHETTI_3D_1: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        49usize,
+        -7i32,
+        &[1f64],
+        11890980020316756032u64,
+        9461961156268492727u64,
+        0.8333333333333333f64,
+    );
+    pub const SPAGHETTI_3D_2: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        50usize,
+        -7i32,
+        &[1f64],
+        13377439611599507183u64,
+        15428434919931579075u64,
+        0.8333333333333333f64,
+    );
+    pub const SPAGHETTI_3D_RARITY: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        51usize,
+        -11i32,
+        &[1f64],
+        17169833707525350457u64,
+        13710596865147759916u64,
+        0.8333333333333333f64,
     );
-    pub const SPAGHETTI_3D_1: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(49usize, -7i32, &[1f64], "minecraft:spaghetti_3d_1");
-    pub const SPAGHETTI_3D_2: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(50usize, -7i32, &[1f64], "minecraft:spaghetti_3d_2");
-    pub const SPAGHETTI_3D_RARITY: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(51usize, -11i32, &[1f64], "minecraft:spaghetti_3d_rarity");
     pub const SPAGHETTI_3D_THICKNESS: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             52usize,
             -8i32,
             &[1f64],
-            "minecraft:spaghetti_3d_thickness",
+            9907390455466502951u64,
+            17587734509872338347u64,
+            0.8333333333333333f64,
+        );
+    pub const SPAGHETTI_ROUGHNESS: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        53usize,
+        -5i32,
+        &[1f64],
+        8857832787093054865u64,
+        15318329311263287229u64,
+        0.8333333333333333f64,
     );
-    pub const SPAGHETTI_ROUGHNESS: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(53usize, -5i32, &[1f64], "minecraft:spaghetti_roughness");
     pub const SPAGHETTI_ROUGHNESS_MODULATOR: DoublePerlinNoiseParameters =
         DoublePerlinNoiseParameters::new(
             54usize,
             -8i32,
             &[1f64],
-            "minecraft:spaghetti_roughness_modulator",
+            16254484819590729386u64,
+            14613561992896323587u64,
+            0.8333333333333333f64,
+        );
+    pub const SURFACE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        55usize,
+        -6i32,
+        &[1f64, 1f64, 1f64],
+        5417997184927261100u64,
+        17624099743590321640u64,
+        1.25f64,
     );
-    pub const SURFACE: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(55usize, -6i32, &[1f64, 1f64, 1f64], "minecraft:surface");
     pub const SURFACE_SECONDARY: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         56usize,
         -6i32,
         &[1f64, 1f64, 0f64, 1f64],
-        "minecraft:surface_secondary",
+        2051559389371867033u64,
+        2317317634050931280u64,
+        1.3333333333333333f64,
+    );
+    pub const SURFACE_SWAMP: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
+        57usize,
+        -2i32,
+        &[1f64],
+        14388971182144335831u64,
+        1415522856927288170u64,
+        0.8333333333333333f64,
     );
-    pub const SURFACE_SWAMP: DoublePerlinNoiseParameters =
-        DoublePerlinNoiseParameters::new(57usize, -2i32, &[1f64], "minecraft:surface_swamp");
     pub const TEMPERATURE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         58usize,
         -10i32,
         &[1.5f64, 0f64, 1f64, 0f64, 0f64, 0f64],
-        "minecraft:temperature",
+        6664882324328353151u64,
+        17859146487254174088u64,
+        1.25f64,
     );
     pub const TEMPERATURE_LARGE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         59usize,
         -12i32,
         &[1.5f64, 0f64, 1f64, 0f64, 0f64, 0f64],
-        "minecraft:temperature_large",
+        10685635038780148187u64,
+        5761303799458311062u64,
+        1.25f64,
     );
     pub const VEGETATION: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         60usize,
         -8i32,
         &[1f64, 1f64, 0f64, 0f64, 0f64, 0f64],
-        "minecraft:vegetation",
+        9348150263868561038u64,
+        17422373889327170509u64,
+        1.111111111111111f64,
     );
     pub const VEGETATION_LARGE: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
         61usize,
         -10i32,
         &[1f64, 1f64, 0f64, 0f64, 0f64, 0f64],
-        "minecraft:vegetation_large",
+        8194488175179944705u64,
+        13502879989887892011u64,
+        1.111111111111111f64,
     );
 }

pumpkin-util/src/lib.rs

@@ -203,6 +203,8 @@ pub struct DoublePerlinNoiseParametersCodec {
     pub first_octave: i32,
     /// Amplitude values for each octave, determining the weight of each frequency layer.
     pub amplitudes: Vec<f64>,
+    #[serde(skip)]
+    pub amplitude: f64,
 }
 
 impl<T> IndexMut<usize> for MutableSplitSlice<'_, T> {

pumpkin-world/src/generation/block_state_provider.rs

@@ -147,6 +147,7 @@ impl DualNoiseBlockStateProvider {
             &mut RandomGenerator::Legacy(LegacyRand::from_seed(self.base.base.seed as u64)),
             self.slow_noise.first_octave,
             &self.slow_noise.amplitudes,
+            self.slow_noise.amplitude,
             false,
         );
         let slow_noise =
@@ -208,6 +209,7 @@ impl NoiseBlockStateProviderBase {
             &mut RandomGenerator::Legacy(LegacyRand::from_seed(self.seed as u64)),
             self.noise.first_octave,
             &self.noise.amplitudes,
+            self.noise.amplitude,
             false,
         );
         sampler.sample(

pumpkin-world/src/generation/feature/features/geode.rs

@@ -18,12 +18,18 @@ use std::cmp::Ordering;
 struct NormalNoise(crate::generation::noise::perlin::DoublePerlinNoiseSampler);
 
 impl NormalNoise {
-    fn create(rand: &mut RandomGenerator, first_octave: i32, amplitudes: &[f64]) -> Self {
+    fn create(
+        rand: &mut RandomGenerator,
+        first_octave: i32,
+        amplitudes: &[f64],
+        amplitude: f64,
+    ) -> Self {
         Self(
             crate::generation::noise::perlin::DoublePerlinNoiseSampler::new(
                 rand,
                 first_octave,
                 amplitudes,
+                amplitude,
                 true,
             ),
         )
@@ -105,7 +111,7 @@ impl GeodeFeature {
     ) -> bool {
         let origin = pos;
         let num_points = self.distribution_points.get(random);
-        let noise = NormalNoise::create(random, -4, &[1.0]);
+        let noise = NormalNoise::create(random, -4, &[1.0], 0.8333333333333333f64);
 
         // Precompute sets of raw block ids for fast lookups
         let mut invalid_raw_ids: HashSet<u16> = HashSet::new();

pumpkin-world/src/generation/noise/perlin.rs

@@ -23,29 +23,25 @@ impl DoublePerlinNoiseSampler {
         parameters: &DoublePerlinNoiseParameters,
         legacy: bool,
     ) -> Self {
-        Self::new(rand, parameters.first_octave, parameters.amplitudes, legacy)
+        Self::new(
+            rand,
+            parameters.first_octave,
+            parameters.amplitudes,
+            parameters.amplitude,
+            legacy,
+        )
     }
 
     pub fn new(
         rand: &mut impl RandomImpl,
         first_octave: i32,
         amplitudes: &[f64],
+        amplitude: f64,
         legacy: bool,
     ) -> Self {
         let first_sampler = OctavePerlinNoiseSampler::new(rand, first_octave, amplitudes, legacy);
         let second_sampler = OctavePerlinNoiseSampler::new(rand, first_octave, amplitudes, legacy);
 
-        let mut j = i32::MAX;
-        let mut k = i32::MIN;
-
-        for (index, amplitude) in amplitudes.iter().enumerate() {
-            if *amplitude != 0f64 {
-                j = i32::min(j, index as i32);
-                k = i32::max(k, index as i32);
-            }
-        }
-
-        let amplitude = 0.16666666666666666f64 / Self::create_amplitude(k - j);
         let max_value = (first_sampler.max_value() + second_sampler.max_value()) * amplitude;
 
         Self {
@@ -80,7 +76,7 @@ mod double_perlin_noise_sampler_test {
         assert_eq!(rand.next_i32(), -1302745855);
 
         let mut rand_gen = RandomGenerator::Legacy(rand);
-        let params = DoublePerlinNoiseParameters::new(0, 0, &[4f64], "");
+        let params = DoublePerlinNoiseParameters::new(0, 0, &[4f64], 1, 1, 1.0);
         let sampler = DoublePerlinNoiseSampler::from_params(&mut rand_gen, &params, true);
 
         let values = [
@@ -178,7 +174,7 @@ mod double_perlin_noise_sampler_test {
 
         let mut rand_gen = RandomGenerator::Xoroshiro(rand);
 
-        let params = DoublePerlinNoiseParameters::new(0, 1, &[2f64, 4f64], "");
+        let params = DoublePerlinNoiseParameters::new(0, 1, &[2f64, 4f64], 1, 1, 1.0);
 
         let sampler = DoublePerlinNoiseSampler::from_params(&mut rand_gen, &params, false);
 

pumpkin-world/src/generation/noise/router/proto_noise_router.rs

@@ -72,7 +72,7 @@ impl DoublePerlinNoiseBuilder {
         base_random_deriver: &XoroshiroSplitter,
         parameters: &DoublePerlinNoiseParameters,
     ) -> DoublePerlinNoiseSampler {
-        let mut random = base_random_deriver.split_string(parameters.name());
+        let mut random = base_random_deriver.from_lo_and_hi(parameters.lo, parameters.hi);
         DoublePerlinNoiseSampler::from_params(&mut random, parameters, false)
     }
 }
@@ -245,8 +245,8 @@ impl ProtoNoiseRouters {
                     // NETHER_TEMPERATURE and NETHER_VEGETATION always use NormalNoise.createLegacyNetherBiome with
                     // LegacyRandomSource(seed + 0) and LegacyRandomSource(seed + 1)
                     // respectively, regardless of useLegacyRandomSource.
-                    let sampler = match data.noise_id.name() {
+                    let sampler = match data.noise_id.id {
-                        "minecraft:nether/temperature" => {
+                        id if id == DoublePerlinNoiseParameters::NETHER_TEMPERATURE.id => {
                             let mut legacy_rand =
                                 LegacyRand::from_seed(random_config.seed.wrapping_add(0));
                             DoublePerlinNoiseSampler::from_params(
@@ -255,7 +255,7 @@ impl ProtoNoiseRouters {
                                 true,
                             )
                         }
-                        "minecraft:nether/vegetation" => {
+                        id if id == DoublePerlinNoiseParameters::NETHER_VEGETATION.id => {
                             let mut legacy_rand =
                                 LegacyRand::from_seed(random_config.seed.wrapping_add(1));
                             DoublePerlinNoiseSampler::from_params(