Pumpkin-MC/Pumpkin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: parse double perlin noise samplers amplitude at compile time

Browse Source
This commit is contained in:
Alexander Medvedev 2026-04-29 16:08:21 +02:00
parent fdf8ff5fd8
commit 427df56935
10 changed files with 413 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pumpkin-codegen/src/block.rs
View File

@ -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();
block_with_descriptors.property_descriptors = property_descriptors;
// let mut block_with_descriptors = block.clone();
// 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 }));

14
pumpkin-codegen/src/configured_feature.rs
View File

@ -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,
}
}
}

68
pumpkin-codegen/src/noise_parameter.rs
View File

@ -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
.strip_prefix("minecraft:")
.unwrap()
.replace("/", "_");
let simple_id = name.clone();
let name = raw_name.strip_prefix("minecraft:").unwrap().replace("/", "_");
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 {
Self {
id,
first_octave,
amplitudes,
name
}
pub const fn new(
id: usize,
first_octave: i32,
amplitudes: &'static [f64],
lo: u64,
hi: u64,
amplitude: f64,
) -> Self {
Self { id, first_octave, amplitudes, lo, hi, amplitude }
}
pub const fn name(&self) -> &'static str {
self.name
}
pub fn id_to_parameters(id: &str) -> Option<&DoublePerlinNoiseParameters> {
Some(match id {
pub fn id_to_parameters(id: &str) -> Option<&'static DoublePerlinNoiseParameters> {
let id = id.strip_prefix("minecraft:").unwrap_or(id).replace("/", "_");
Some(match id.as_str() {
#match_variants
_ => return None,
})
@ -70,6 +91,5 @@ pub fn build() -> TokenStream {
#variants
}
}
}

4
pumpkin-data/src/generated/configured_features_generated.rs
View File

@ -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,
},

415
pumpkin-data/src/generated/noise_parameter.rs
View File

@ -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 {
self.name
}
pub fn id_to_parameters(id: &str) -> Option<&DoublePerlinNoiseParameters> {
Some(match id {
pub fn id_to_parameters(id: &str) -> Option<&'static DoublePerlinNoiseParameters> {
let id = id
.strip_prefix("minecraft:")
.unwrap_or(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 =
DoublePerlinNoiseParameters::new(0usize, -3i32, &[1f64], "minecraft:aquifer_barrier");
pub const AQUIFER_BARRIER: DoublePerlinNoiseParameters = DoublePerlinNoiseParameters::new(
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,
);
}

2
pumpkin-util/src/lib.rs
View File

@ -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> {

2
pumpkin-world/src/generation/block_state_provider.rs
View File

@ -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(

10
pumpkin-world/src/generation/feature/features/geode.rs
View File

@ -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();

24
pumpkin-world/src/generation/noise/perlin.rs
View File

@ -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);

8
pumpkin-world/src/generation/noise/router/proto_noise_router.rs
View File

@ -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() {
"minecraft:nether/temperature" => {
let sampler = match data.noise_id.id {
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(