Struct NormalNoise 

pub struct NormalNoise {
    first: PerlinNoise,
    second: PerlinNoise,
    value_factor: f64,
    max_value: f64,
}

Normal (Double Perlin) noise generator.

Combines two PerlinNoise samplers with different coordinate scales to create smoother noise. The result is scaled by a value factor based on the octave span.

Fields

first: PerlinNoise

First Perlin noise sampler

second: PerlinNoise

Second Perlin noise sampler (coordinates scaled by INPUT_FACTOR)

value_factor: f64

Factor applied to the sum of both samplers

max_value: f64

Maximum possible output value

Implementations

impl NormalNoise

pub fn create_from_random( random: &mut RandomSource, first_octave: i32, amplitudes: &[f64], ) -> Self

Create a new NormalNoise from a mutable sequential random source.

This matches vanilla’s NormalNoise constructor:

1. Create first PerlinNoise (which advances the random state by consuming 262 + forking)
2. Create second PerlinNoise (which sees the advanced state)

This ensures the two PerlinNoise instances have different seeds.

pub fn create( splitter: &RandomSplitter, noise_id: &str, first_octave: i32, amplitudes: &[f64], ) -> Self

Create a new NormalNoise from a positional random splitter.

Note: This creates a sequential random source from the splitter’s noise ID, then delegates to create_from_random for vanilla-matching behavior.

pub fn create_legacy_nether_biome( random: &mut RandomSource, first_octave: i32, amplitudes: &[f64], ) -> Self

Create a NormalNoise using the legacy nether biome initialization path.

This uses PerlinNoise::create_legacy_for_nether instead of the hash-based positional seeding. The ImprovedNoise instances are created directly from a sequential LegacyRandomSource. Matches vanilla’s NormalNoise.createLegacyNetherBiome().

fn finish(first: PerlinNoise, second: PerlinNoise, amplitudes: &[f64]) -> Self

Finish construction with the two PerlinNoise instances.

pub fn get_value(&self, x: f64, y: f64, z: f64) -> f64

Sample the noise at the given coordinates.

The result combines two Perlin noise samples:

• First sampler at (x, y, z)
• Second sampler at (x * INPUT_FACTOR, y * INPUT_FACTOR, z * INPUT_FACTOR)

The sum is then scaled by the value factor.

pub fn get_value_simd<F, const N: usize>( &self, x: Simd<F, N>, y: Simd<F, N>, z: Simd<F, N>, ) -> Simd<F, N>

where F: SimdElement + SimdCast, Simd<F, N>: SimdFloat<Cast<i32> = Simd<i32, N>> + SimdPartialOrd + SimdPartialEq<Mask = Mask<<F as SimdElement>::Mask, N>> + Add<Output = Simd<F, N>> + Sub<Output = Simd<F, N>> + Mul<Output = Simd<F, N>> + Div<Output = Simd<F, N>> + Neg<Output = Simd<F, N>> + StdFloat,

Calculate normal noise value using SIMD vectors.

pub fn get_value_xz(&self, x: f64, z: f64) -> f64

Sample the noise at (x, 0.0, z).

pub fn get_value_xy(&self, x: f64, y: f64) -> f64

Sample the noise at (x, y, 0.0).

pub fn get_value_y_4x(&self, x: f64, ys: f64x4, z: f64) -> f64x4

Sample 4 Y values at fixed (x, z) in one call.

pub fn get_value_y_simd<const N: usize>( &self, x: f64, ys: Simd<f64, N>, z: f64, ) -> Simd<f64, N>

Sample N Y values at fixed (x, z) in one call.

SIMD form of Self::get_value for transpiled density-function trees that batch N cell-corner Ys together. Per-lane math is identical to the scalar path, so get_value_y_simd(x, splat(y), z)[i] == get_value(x, y, z) for any finite y.

pub const fn max_value(&self) -> f64

Get the maximum possible output value.

Trait Implementations

impl Clone for NormalNoise

fn clone(&self) -> NormalNoise

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NormalNoise

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.